Package kotlin.collections

Types

Link copied to clipboard
abstract class AbstractCollection<out E> : Collection<E>
Link copied to clipboard
abstract class AbstractIterator<T> : Iterator<T>
Link copied to clipboard
abstract class AbstractList<out E> : AbstractCollection<E> , List<E>
Link copied to clipboard
abstract class AbstractMap<K, out V> : Map<K, V>
Link copied to clipboard
abstract class AbstractMutableCollection<E> : AbstractCollection<E> , MutableCollection<E>
Link copied to clipboard
abstract class AbstractMutableList<E> : AbstractMutableCollection<E> , MutableList<E>
Link copied to clipboard
abstract class AbstractMutableMap<K, V> : AbstractMap<K, V> , MutableMap<K, V>
Link copied to clipboard
abstract class AbstractMutableSet<E> : AbstractMutableCollection<E> , MutableSet<E>
Link copied to clipboard
abstract class AbstractSet<out E> : AbstractCollection<E> , Set<E>
Link copied to clipboard
class ArrayDeque<E> : AbstractMutableList<E>
Link copied to clipboard
open class ArrayList<E> : AbstractMutableList<E> , MutableList<E> , RandomAccess
Link copied to clipboard
abstract class BooleanIterator : Iterator<Boolean>
abstract class BooleanIterator : Iterator<Boolean>
Link copied to clipboard
abstract class ByteIterator : Iterator<Byte>
abstract class ByteIterator : Iterator<Byte>
Link copied to clipboard
abstract class CharIterator : Iterator<Char>
abstract class CharIterator : Iterator<Char>
Link copied to clipboard
interface Collection<out E> : Iterable<E>
interface Collection<out E> : Iterable<E>
Link copied to clipboard
abstract class DoubleIterator : Iterator<Double>
abstract class DoubleIterator : Iterator<Double>
Link copied to clipboard
abstract class FloatIterator : Iterator<Float>
abstract class FloatIterator : Iterator<Float>
Link copied to clipboard
interface Grouping<T, out K>
Link copied to clipboard
open class HashMap<K, V> : AbstractMutableMap<K, V> , MutableMap<K, V>
Link copied to clipboard
open class HashSet<E> : AbstractMutableSet<E> , MutableSet<E>
Link copied to clipboard
data class IndexedValue<out T>
Link copied to clipboard
abstract class IntIterator : Iterator<Int>
abstract class IntIterator : Iterator<Int>
Link copied to clipboard
interface Iterable<out T>
interface Iterable<out T>
Link copied to clipboard
interface Iterator<out T>
interface Iterator<out T>
Link copied to clipboard
open class LinkedHashMap<K, V> : HashMap<K, V> , MutableMap<K, V>
Link copied to clipboard
open class LinkedHashSet<E> : HashSet<E> , MutableSet<E>
Link copied to clipboard
interface List<out E> : Collection<E>
interface List<out E> : Collection<E>
Link copied to clipboard
interface ListIterator<out T> : Iterator<T>
interface ListIterator<out T> : Iterator<T>
Link copied to clipboard
abstract class LongIterator : Iterator<Long>
abstract class LongIterator : Iterator<Long>
Link copied to clipboard
interface Map<K, out V>
interface Map<K, out V>
Link copied to clipboard
interface MutableCollection<E> : Collection<E> , MutableIterable<E>
interface MutableCollection<E> : Collection<E> , MutableIterable<E>
Link copied to clipboard
interface MutableIterable<out T> : Iterable<T>
interface MutableIterable<out T> : Iterable<T>
Link copied to clipboard
interface MutableIterator<out T> : Iterator<T>
interface MutableIterator<out T> : Iterator<T>
Link copied to clipboard
interface MutableList<E> : List<E> , MutableCollection<E>
interface MutableList<E> : List<E> , MutableCollection<E>
Link copied to clipboard
interface MutableListIterator<T> : ListIterator<T> , MutableIterator<T>
interface MutableListIterator<T> : ListIterator<T> , MutableIterator<T>
Link copied to clipboard
interface MutableMap<K, V> : Map<K, V>
interface MutableMap<K, V> : Map<K, V>
Link copied to clipboard
interface MutableSet<E> : Set<E> , MutableCollection<E>
interface MutableSet<E> : Set<E> , MutableCollection<E>
Link copied to clipboard
interface RandomAccess
Link copied to clipboard
interface Set<out E> : Collection<E>
interface Set<out E> : Collection<E>
Link copied to clipboard
abstract class ShortIterator : Iterator<Short>
abstract class ShortIterator : Iterator<Short>

Functions

Link copied to clipboard
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
fun <no name provided>()
Link copied to clipboard
fun <T> MutableCollection<in T>.addAll(elements: Array<out T>): Boolean
fun <T> MutableCollection<in T>.addAll(elements: Iterable<T>): Boolean
fun <T> MutableCollection<in T>.addAll(elements: Sequence<T>): Boolean
Link copied to clipboard
inline fun <T, K, R> Grouping<T, K>.aggregate(operation: (key: K, accumulator: R?, element: T, first: Boolean) -> R): Map<K, R>
Link copied to clipboard
inline fun <T, K, R, M : MutableMap<in K, R>> Grouping<T, K>.aggregateTo(destination: M, operation: (key: K, accumulator: R?, element: T, first: Boolean) -> R): M
Link copied to clipboard
inline fun <T> Array<out T>.all(predicate: (T) -> Boolean): Boolean
inline fun BooleanArray.all(predicate: (Boolean) -> Boolean): Boolean
inline fun ByteArray.all(predicate: (Byte) -> Boolean): Boolean
inline fun CharArray.all(predicate: (Char) -> Boolean): Boolean
inline fun DoubleArray.all(predicate: (Double) -> Boolean): Boolean
inline fun FloatArray.all(predicate: (Float) -> Boolean): Boolean
inline fun IntArray.all(predicate: (Int) -> Boolean): Boolean
inline fun LongArray.all(predicate: (Long) -> Boolean): Boolean
inline fun ShortArray.all(predicate: (Short) -> Boolean): Boolean
inline fun UByteArray.all(predicate: (UByte) -> Boolean): Boolean
inline fun UIntArray.all(predicate: (UInt) -> Boolean): Boolean
inline fun ULongArray.all(predicate: (ULong) -> Boolean): Boolean
inline fun UShortArray.all(predicate: (UShort) -> Boolean): Boolean
inline fun <T> Iterable<T>.all(predicate: (T) -> Boolean): Boolean
inline fun <K, V> Map<out K, V>.all(predicate: (Map.Entry<K, V>) -> Boolean): Boolean
Link copied to clipboard
fun <T> Array<out T>.any(): Boolean
fun BooleanArray.any(): Boolean
fun ByteArray.any(): Boolean
fun CharArray.any(): Boolean
fun DoubleArray.any(): Boolean
fun FloatArray.any(): Boolean
fun IntArray.any(): Boolean
fun LongArray.any(): Boolean
fun ShortArray.any(): Boolean
inline fun UByteArray.any(): Boolean
inline fun UIntArray.any(): Boolean
inline fun ULongArray.any(): Boolean
inline fun UShortArray.any(): Boolean
fun <T> Iterable<T>.any(): Boolean
fun <K, V> Map<out K, V>.any(): Boolean
inline fun <T> Array<out T>.any(predicate: (T) -> Boolean): Boolean
inline fun BooleanArray.any(predicate: (Boolean) -> Boolean): Boolean
inline fun ByteArray.any(predicate: (Byte) -> Boolean): Boolean
inline fun CharArray.any(predicate: (Char) -> Boolean): Boolean
inline fun DoubleArray.any(predicate: (Double) -> Boolean): Boolean
inline fun FloatArray.any(predicate: (Float) -> Boolean): Boolean
inline fun IntArray.any(predicate: (Int) -> Boolean): Boolean
inline fun LongArray.any(predicate: (Long) -> Boolean): Boolean
inline fun ShortArray.any(predicate: (Short) -> Boolean): Boolean
inline fun UByteArray.any(predicate: (UByte) -> Boolean): Boolean
inline fun UIntArray.any(predicate: (UInt) -> Boolean): Boolean
inline fun ULongArray.any(predicate: (ULong) -> Boolean): Boolean
inline fun UShortArray.any(predicate: (UShort) -> Boolean): Boolean
inline fun <T> Iterable<T>.any(predicate: (T) -> Boolean): Boolean
inline fun <K, V> Map<out K, V>.any(predicate: (Map.Entry<K, V>) -> Boolean): Boolean
Link copied to clipboard
inline fun <T> arrayListOf(): ArrayList<T>
fun <T> arrayListOf(vararg elements: T): ArrayList<T>
Link copied to clipboard
inline fun UByteArray.asByteArray(): ByteArray
Link copied to clipboard
inline fun UIntArray.asIntArray(): IntArray
Link copied to clipboard
fun <T> Array<out T>.asIterable(): Iterable<T>
fun BooleanArray.asIterable(): Iterable<Boolean>
fun ByteArray.asIterable(): Iterable<Byte>
fun CharArray.asIterable(): Iterable<Char>
fun DoubleArray.asIterable(): Iterable<Double>
fun FloatArray.asIterable(): Iterable<Float>
fun IntArray.asIterable(): Iterable<Int>
fun LongArray.asIterable(): Iterable<Long>
fun ShortArray.asIterable(): Iterable<Short>
inline fun <T> Iterable<T>.asIterable(): Iterable<T>
inline fun <K, V> Map<out K, V>.asIterable(): Iterable<Map.Entry<K, V>>
Link copied to clipboard
fun <T> Array<out T>.asList(): List<T>
inline fun BooleanArray.asList(): List<Boolean>
inline fun ByteArray.asList(): List<Byte>
fun CharArray.asList(): List<Char>
inline fun DoubleArray.asList(): List<Double>
inline fun FloatArray.asList(): List<Float>
inline fun IntArray.asList(): List<Int>
inline fun LongArray.asList(): List<Long>
inline fun ShortArray.asList(): List<Short>
fun UByteArray.asList(): List<UByte>
fun UIntArray.asList(): List<UInt>
fun ULongArray.asList(): List<ULong>
fun UShortArray.asList(): List<UShort>
Link copied to clipboard
inline fun ULongArray.asLongArray(): LongArray
Link copied to clipboard
fun <T> List<T>.asReversed(): List<T>
@JvmName(name = "asReversedMutable")
fun <T> MutableList<T>.asReversed(): MutableList<T>
Link copied to clipboard
fun <T> Array<out T>.asSequence(): Sequence<T>
fun BooleanArray.asSequence(): Sequence<Boolean>
fun ByteArray.asSequence(): Sequence<Byte>
fun CharArray.asSequence(): Sequence<Char>
fun DoubleArray.asSequence(): Sequence<Double>
fun FloatArray.asSequence(): Sequence<Float>
fun IntArray.asSequence(): Sequence<Int>
fun LongArray.asSequence(): Sequence<Long>
fun ShortArray.asSequence(): Sequence<Short>
fun <T> Iterable<T>.asSequence(): Sequence<T>
fun <K, V> Map<out K, V>.asSequence(): Sequence<Map.Entry<K, V>>
Link copied to clipboard
inline fun UShortArray.asShortArray(): ShortArray
Link copied to clipboard
inline fun <T, K, V> Array<out T>.associate(transform: (T) -> Pair<K, V>): Map<K, V>
inline fun <K, V> BooleanArray.associate(transform: (Boolean) -> Pair<K, V>): Map<K, V>
inline fun <K, V> ByteArray.associate(transform: (Byte) -> Pair<K, V>): Map<K, V>
inline fun <K, V> CharArray.associate(transform: (Char) -> Pair<K, V>): Map<K, V>
inline fun <K, V> DoubleArray.associate(transform: (Double) -> Pair<K, V>): Map<K, V>
inline fun <K, V> FloatArray.associate(transform: (Float) -> Pair<K, V>): Map<K, V>
inline fun <K, V> IntArray.associate(transform: (Int) -> Pair<K, V>): Map<K, V>
inline fun <K, V> LongArray.associate(transform: (Long) -> Pair<K, V>): Map<K, V>
inline fun <K, V> ShortArray.associate(transform: (Short) -> Pair<K, V>): Map<K, V>
inline fun <T, K, V> Iterable<T>.associate(transform: (T) -> Pair<K, V>): Map<K, V>
Link copied to clipboard
inline fun <T, K> Array<out T>.associateBy(keySelector: (T) -> K): Map<K, T>
inline fun <K> BooleanArray.associateBy(keySelector: (Boolean) -> K): Map<K, Boolean>
inline fun <K> ByteArray.associateBy(keySelector: (Byte) -> K): Map<K, Byte>
inline fun <K> CharArray.associateBy(keySelector: (Char) -> K): Map<K, Char>
inline fun <K> DoubleArray.associateBy(keySelector: (Double) -> K): Map<K, Double>
inline fun <K> FloatArray.associateBy(keySelector: (Float) -> K): Map<K, Float>
inline fun <K> IntArray.associateBy(keySelector: (Int) -> K): Map<K, Int>
inline fun <K> LongArray.associateBy(keySelector: (Long) -> K): Map<K, Long>
inline fun <K> ShortArray.associateBy(keySelector: (Short) -> K): Map<K, Short>
inline fun <T, K> Iterable<T>.associateBy(keySelector: (T) -> K): Map<K, T>
inline fun <T, K, V> Array<out T>.associateBy(keySelector: (T) -> K, valueTransform: (T) -> V): Map<K, V>
inline fun <K, V> BooleanArray.associateBy(keySelector: (Boolean) -> K, valueTransform: (Boolean) -> V): Map<K, V>
inline fun <K, V> ByteArray.associateBy(keySelector: (Byte) -> K, valueTransform: (Byte) -> V): Map<K, V>
inline fun <K, V> CharArray.associateBy(keySelector: (Char) -> K, valueTransform: (Char) -> V): Map<K, V>
inline fun <K, V> DoubleArray.associateBy(keySelector: (Double) -> K, valueTransform: (Double) -> V): Map<K, V>
inline fun <K, V> FloatArray.associateBy(keySelector: (Float) -> K, valueTransform: (Float) -> V): Map<K, V>
inline fun <K, V> IntArray.associateBy(keySelector: (Int) -> K, valueTransform: (Int) -> V): Map<K, V>
inline fun <K, V> LongArray.associateBy(keySelector: (Long) -> K, valueTransform: (Long) -> V): Map<K, V>
inline fun <K, V> ShortArray.associateBy(keySelector: (Short) -> K, valueTransform: (Short) -> V): Map<K, V>
inline fun <T, K, V> Iterable<T>.associateBy(keySelector: (T) -> K, valueTransform: (T) -> V): Map<K, V>
Link copied to clipboard
inline fun <T, K, M : MutableMap<in K, in T>> Array<out T>.associateByTo(destination: M, keySelector: (T) -> K): M
inline fun <K, M : MutableMap<in K, in Boolean>> BooleanArray.associateByTo(destination: M, keySelector: (Boolean) -> K): M
inline fun <K, M : MutableMap<in K, in Byte>> ByteArray.associateByTo(destination: M, keySelector: (Byte) -> K): M
inline fun <K, M : MutableMap<in K, in Char>> CharArray.associateByTo(destination: M, keySelector: (Char) -> K): M
inline fun <K, M : MutableMap<in K, in Double>> DoubleArray.associateByTo(destination: M, keySelector: (Double) -> K): M
inline fun <K, M : MutableMap<in K, in Float>> FloatArray.associateByTo(destination: M, keySelector: (Float) -> K): M
inline fun <K, M : MutableMap<in K, in Int>> IntArray.associateByTo(destination: M, keySelector: (Int) -> K): M
inline fun <K, M : MutableMap<in K, in Long>> LongArray.associateByTo(destination: M, keySelector: (Long) -> K): M
inline fun <K, M : MutableMap<in K, in Short>> ShortArray.associateByTo(destination: M, keySelector: (Short) -> K): M
inline fun <T, K, M : MutableMap<in K, in T>> Iterable<T>.associateByTo(destination: M, keySelector: (T) -> K): M
inline fun <T, K, V, M : MutableMap<in K, in V>> Array<out T>.associateByTo(    destination: M,     keySelector: (T) -> K,     valueTransform: (T) -> V): M
inline fun <K, V, M : MutableMap<in K, in V>> BooleanArray.associateByTo(    destination: M,     keySelector: (Boolean) -> K,     valueTransform: (Boolean) -> V): M
inline fun <K, V, M : MutableMap<in K, in V>> ByteArray.associateByTo(    destination: M,     keySelector: (Byte) -> K,     valueTransform: (Byte) -> V): M
inline fun <K, V, M : MutableMap<in K, in V>> CharArray.associateByTo(    destination: M,     keySelector: (Char) -> K,     valueTransform: (Char) -> V): M
inline fun <K, V, M : MutableMap<in K, in V>> DoubleArray.associateByTo(    destination: M,     keySelector: (Double) -> K,     valueTransform: (Double) -> V): M
inline fun <K, V, M : MutableMap<in K, in V>> FloatArray.associateByTo(    destination: M,     keySelector: (Float) -> K,     valueTransform: (Float) -> V): M
inline fun <K, V, M : MutableMap<in K, in V>> IntArray.associateByTo(    destination: M,     keySelector: (Int) -> K,     valueTransform: (Int) -> V): M
inline fun <K, V, M : MutableMap<in K, in V>> LongArray.associateByTo(    destination: M,     keySelector: (Long) -> K,     valueTransform: (Long) -> V): M
inline fun <K, V, M : MutableMap<in K, in V>> ShortArray.associateByTo(    destination: M,     keySelector: (Short) -> K,     valueTransform: (Short) -> V): M
inline fun <T, K, V, M : MutableMap<in K, in V>> Iterable<T>.associateByTo(    destination: M,     keySelector: (T) -> K,     valueTransform: (T) -> V): M
Link copied to clipboard
inline fun <T, K, V, M : MutableMap<in K, in V>> Array<out T>.associateTo(destination: M, transform: (T) -> Pair<K, V>): M
inline fun <K, V, M : MutableMap<in K, in V>> BooleanArray.associateTo(destination: M, transform: (Boolean) -> Pair<K, V>): M
inline fun <K, V, M : MutableMap<in K, in V>> ByteArray.associateTo(destination: M, transform: (Byte) -> Pair<K, V>): M
inline fun <K, V, M : MutableMap<in K, in V>> CharArray.associateTo(destination: M, transform: (Char) -> Pair<K, V>): M
inline fun <K, V, M : MutableMap<in K, in V>> DoubleArray.associateTo(destination: M, transform: (Double) -> Pair<K, V>): M
inline fun <K, V, M : MutableMap<in K, in V>> FloatArray.associateTo(destination: M, transform: (Float) -> Pair<K, V>): M
inline fun <K, V, M : MutableMap<in K, in V>> IntArray.associateTo(destination: M, transform: (Int) -> Pair<K, V>): M
inline fun <K, V, M : MutableMap<in K, in V>> LongArray.associateTo(destination: M, transform: (Long) -> Pair<K, V>): M
inline fun <K, V, M : MutableMap<in K, in V>> ShortArray.associateTo(destination: M, transform: (Short) -> Pair<K, V>): M
inline fun <T, K, V, M : MutableMap<in K, in V>> Iterable<T>.associateTo(destination: M, transform: (T) -> Pair<K, V>): M
Link copied to clipboard
inline fun <K, V> Array<out K>.associateWith(valueSelector: (K) -> V): Map<K, V>
inline fun <V> BooleanArray.associateWith(valueSelector: (Boolean) -> V): Map<Boolean, V>
inline fun <V> ByteArray.associateWith(valueSelector: (Byte) -> V): Map<Byte, V>
inline fun <V> CharArray.associateWith(valueSelector: (Char) -> V): Map<Char, V>
inline fun <V> DoubleArray.associateWith(valueSelector: (Double) -> V): Map<Double, V>
inline fun <V> FloatArray.associateWith(valueSelector: (Float) -> V): Map<Float, V>
inline fun <V> IntArray.associateWith(valueSelector: (Int) -> V): Map<Int, V>
inline fun <V> LongArray.associateWith(valueSelector: (Long) -> V): Map<Long, V>
inline fun <V> ShortArray.associateWith(valueSelector: (Short) -> V): Map<Short, V>
inline fun <V> UByteArray.associateWith(valueSelector: (UByte) -> V): Map<UByte, V>
inline fun <V> UIntArray.associateWith(valueSelector: (UInt) -> V): Map<UInt, V>
inline fun <V> ULongArray.associateWith(valueSelector: (ULong) -> V): Map<ULong, V>
inline fun <V> UShortArray.associateWith(valueSelector: (UShort) -> V): Map<UShort, V>
inline fun <K, V> Iterable<K>.associateWith(valueSelector: (K) -> V): Map<K, V>
Link copied to clipboard
inline fun <K, V, M : MutableMap<in K, in V>> Array<out K>.associateWithTo(destination: M, valueSelector: (K) -> V): M
inline fun <V, M : MutableMap<in Boolean, in V>> BooleanArray.associateWithTo(destination: M, valueSelector: (Boolean) -> V): M
inline fun <V, M : MutableMap<in Byte, in V>> ByteArray.associateWithTo(destination: M, valueSelector: (Byte) -> V): M
inline fun <V, M : MutableMap<in Char, in V>> CharArray.associateWithTo(destination: M, valueSelector: (Char) -> V): M
inline fun <V, M : MutableMap<in Double, in V>> DoubleArray.associateWithTo(destination: M, valueSelector: (Double) -> V): M
inline fun <V, M : MutableMap<in Float, in V>> FloatArray.associateWithTo(destination: M, valueSelector: (Float) -> V): M
inline fun <V, M : MutableMap<in Int, in V>> IntArray.associateWithTo(destination: M, valueSelector: (Int) -> V): M
inline fun <V, M : MutableMap<in Long, in V>> LongArray.associateWithTo(destination: M, valueSelector: (Long) -> V): M
inline fun <V, M : MutableMap<in Short, in V>> ShortArray.associateWithTo(destination: M, valueSelector: (Short) -> V): M
inline fun <V, M : MutableMap<in UByte, in V>> UByteArray.associateWithTo(destination: M, valueSelector: (UByte) -> V): M
inline fun <V, M : MutableMap<in UInt, in V>> UIntArray.associateWithTo(destination: M, valueSelector: (UInt) -> V): M
inline fun <V, M : MutableMap<in ULong, in V>> ULongArray.associateWithTo(destination: M, valueSelector: (ULong) -> V): M
inline fun <V, M : MutableMap<in UShort, in V>> UShortArray.associateWithTo(destination: M, valueSelector: (UShort) -> V): M
inline fun <K, V, M : MutableMap<in K, in V>> Iterable<K>.associateWithTo(destination: M, valueSelector: (K) -> V): M
Link copied to clipboard
inline fun ByteArray.asUByteArray(): UByteArray
Link copied to clipboard
inline fun IntArray.asUIntArray(): UIntArray
Link copied to clipboard
inline fun LongArray.asULongArray(): ULongArray
Link copied to clipboard
inline fun ShortArray.asUShortArray(): UShortArray
Link copied to clipboard
@JvmName(name = "averageOfByte")
fun ByteArray.average(): Double
@JvmName(name = "averageOfDouble")
fun DoubleArray.average(): Double
@JvmName(name = "averageOfFloat")
fun FloatArray.average(): Double
@JvmName(name = "averageOfInt")
fun IntArray.average(): Double
@JvmName(name = "averageOfLong")
fun LongArray.average(): Double
@JvmName(name = "averageOfShort")
fun ShortArray.average(): Double
fun ByteArray.average(): Double
fun DoubleArray.average(): Double
fun FloatArray.average(): Double
fun IntArray.average(): Double
fun LongArray.average(): Double
fun ShortArray.average(): Double
@JvmName(name = "averageOfByte")
fun Iterable<Byte>.average(): Double
@JvmName(name = "averageOfDouble")
fun Iterable<Double>.average(): Double
@JvmName(name = "averageOfFloat")
fun Iterable<Float>.average(): Double
@JvmName(name = "averageOfInt")
fun Iterable<Int>.average(): Double
@JvmName(name = "averageOfLong")
fun Iterable<Long>.average(): Double
@JvmName(name = "averageOfShort")
fun Iterable<Short>.average(): Double
Link copied to clipboard
fun <T> List<T>.binarySearch(fromIndex: Int)
fun <T : Comparable<T>> List<T?>.binarySearch(element: T?, fromIndex: Int)
fun <T> List<T>.binarySearch(    element: T,     comparator: Comparator<in T>,     fromIndex: Int)
Link copied to clipboard
inline fun <T, K : Comparable<K>> List<T>.binarySearchBy(key: K?, fromIndex: Int)
Link copied to clipboard
inline fun <E> buildList(builderAction: MutableList<E>.() -> Unit): List<E>
inline fun <E> buildList(capacity: Int, builderAction: MutableList<E>.() -> Unit): List<E>
Link copied to clipboard
inline fun <K, V> buildMap(builderAction: MutableMap<K, V>.() -> Unit): Map<K, V>
inline fun <K, V> buildMap(capacity: Int, builderAction: MutableMap<K, V>.() -> Unit): Map<K, V>
Link copied to clipboard
inline fun <E> buildSet(builderAction: MutableSet<E>.() -> Unit): Set<E>
inline fun <E> buildSet(capacity: Int, builderAction: MutableSet<E>.() -> Unit): Set<E>
Link copied to clipboard
fun <T> Iterable<T>.chunked(size: Int): List<List<T>>
fun <T, R> Iterable<T>.chunked(size: Int, transform: (List<T>) -> R): List<R>
Link copied to clipboard
inline operator fun <T> Array<out T>.component1(): T
inline operator fun BooleanArray.component1(): Boolean
inline operator fun ByteArray.component1(): Byte
inline operator fun CharArray.component1(): Char
inline operator fun DoubleArray.component1(): Double
inline operator fun FloatArray.component1(): Float
inline operator fun IntArray.component1(): Int
inline operator fun LongArray.component1(): Long
inline operator fun ShortArray.component1(): Short
inline operator fun UByteArray.component1(): UByte
inline operator fun UIntArray.component1(): UInt
inline operator fun ULongArray.component1(): ULong
inline operator fun UShortArray.component1(): UShort
inline operator fun <T> List<T>.component1(): T
inline operator fun <K, V> Map.Entry<K, V>.component1(): K
Link copied to clipboard
inline operator fun <T> Array<out T>.component2(): T
inline operator fun BooleanArray.component2(): Boolean
inline operator fun ByteArray.component2(): Byte
inline operator fun CharArray.component2(): Char
inline operator fun DoubleArray.component2(): Double
inline operator fun FloatArray.component2(): Float
inline operator fun IntArray.component2(): Int
inline operator fun LongArray.component2(): Long
inline operator fun ShortArray.component2(): Short
inline operator fun UByteArray.component2(): UByte
inline operator fun UIntArray.component2(): UInt
inline operator fun ULongArray.component2(): ULong
inline operator fun UShortArray.component2(): UShort
inline operator fun <T> List<T>.component2(): T
inline operator fun <K, V> Map.Entry<K, V>.component2(): V
Link copied to clipboard
inline operator fun <T> Array<out T>.component3(): T
inline operator fun BooleanArray.component3(): Boolean
inline operator fun ByteArray.component3(): Byte
inline operator fun CharArray.component3(): Char
inline operator fun DoubleArray.component3(): Double
inline operator fun FloatArray.component3(): Float
inline operator fun IntArray.component3(): Int
inline operator fun LongArray.component3(): Long
inline operator fun ShortArray.component3(): Short
inline operator fun UByteArray.component3(): UByte
inline operator fun UIntArray.component3(): UInt
inline operator fun ULongArray.component3(): ULong
inline operator fun UShortArray.component3(): UShort
inline operator fun <T> List<T>.component3(): T
Link copied to clipboard
inline operator fun <T> Array<out T>.component4(): T
inline operator fun BooleanArray.component4(): Boolean
inline operator fun ByteArray.component4(): Byte
inline operator fun CharArray.component4(): Char
inline operator fun DoubleArray.component4(): Double
inline operator fun FloatArray.component4(): Float
inline operator fun IntArray.component4(): Int
inline operator fun LongArray.component4(): Long
inline operator fun ShortArray.component4(): Short
inline operator fun UByteArray.component4(): UByte
inline operator fun UIntArray.component4(): UInt
inline operator fun ULongArray.component4(): ULong
inline operator fun UShortArray.component4(): UShort
inline operator fun <T> List<T>.component4(): T
Link copied to clipboard
inline operator fun <T> Array<out T>.component5(): T
inline operator fun BooleanArray.component5(): Boolean
inline operator fun ByteArray.component5(): Byte
inline operator fun CharArray.component5(): Char
inline operator fun DoubleArray.component5(): Double
inline operator fun FloatArray.component5(): Float
inline operator fun IntArray.component5(): Int
inline operator fun LongArray.component5(): Long
inline operator fun ShortArray.component5(): Short
inline operator fun UByteArray.component5(): UByte
inline operator fun UIntArray.component5(): UInt
inline operator fun ULongArray.component5(): ULong
inline operator fun UShortArray.component5(): UShort
inline operator fun <T> List<T>.component5(): T
Link copied to clipboard
operator fun <T> Array<out T>.contains(element: T): Boolean
operator fun BooleanArray.contains(element: Boolean): Boolean
operator fun ByteArray.contains(element: Byte): Boolean
operator fun CharArray.contains(element: Char): Boolean
@DeprecatedSinceKotlin(errorSince = "1.6", hiddenSince = "1.7", warningSince = "1.4")
operator fun DoubleArray.contains(element: Double): Boolean
@DeprecatedSinceKotlin(errorSince = "1.6", hiddenSince = "1.7", warningSince = "1.4")
operator fun FloatArray.contains(element: Float): Boolean
operator fun IntArray.contains(element: Int): Boolean
operator fun LongArray.contains(element: Long): Boolean
operator fun ShortArray.contains(element: Short): Boolean
operator fun <T> Iterable<T>.contains(element: T): Boolean
inline operator fun <K, V> Map<out K, V>.contains(key: K): Boolean
Link copied to clipboard
inline fun <T> Collection<T>.containsAll(elements: Collection<T>): Boolean
Link copied to clipboard
inline fun <K> Map<out K, *>.containsKey(key: K): Boolean
Link copied to clipboard
inline fun <K, V> Map<K, V>.containsValue(value: V): Boolean
Link copied to clipboard
infix fun <T> Array<out T>.contentDeepEquals(other: Array<out T>): Boolean
infix fun <T> Array<out T>?.contentDeepEquals(other: Array<out T>?): Boolean
Link copied to clipboard
fun <T> Array<out T>.contentDeepHashCode(): Int
fun <T> Array<out T>?.contentDeepHashCode(): Int
Link copied to clipboard
fun <T> Array<out T>.contentDeepToString(): String
fun <T> Array<out T>?.contentDeepToString(): String
Link copied to clipboard
@DeprecatedSinceKotlin(hiddenSince = "1.4")
infix fun <T> Array<out T>.contentEquals(other: Array<out T>): Boolean
infix fun <T> Array<out T>?.contentEquals(other: Array<out T>?): Boolean
@DeprecatedSinceKotlin(hiddenSince = "1.4")
infix fun BooleanArray.contentEquals(other: BooleanArray): Boolean
infix fun BooleanArray?.contentEquals(other: BooleanArray?): Boolean
@DeprecatedSinceKotlin(hiddenSince = "1.4")
infix fun ByteArray.contentEquals(other: ByteArray): Boolean
infix fun ByteArray?.contentEquals(other: ByteArray?): Boolean
@DeprecatedSinceKotlin(hiddenSince = "1.4")
infix fun CharArray.contentEquals(other: CharArray): Boolean
infix fun CharArray?.contentEquals(other: CharArray?): Boolean
@DeprecatedSinceKotlin(hiddenSince = "1.4")
infix fun DoubleArray.contentEquals(other: DoubleArray): Boolean
infix fun DoubleArray?.contentEquals(other: DoubleArray?): Boolean
@DeprecatedSinceKotlin(hiddenSince = "1.4")
infix fun FloatArray.contentEquals(other: FloatArray): Boolean
infix fun FloatArray?.contentEquals(other: FloatArray?): Boolean
@DeprecatedSinceKotlin(hiddenSince = "1.4")
infix fun IntArray.contentEquals(other: IntArray): Boolean
infix fun IntArray?.contentEquals(other: IntArray?): Boolean
@DeprecatedSinceKotlin(hiddenSince = "1.4")
infix fun LongArray.contentEquals(other: LongArray): Boolean
infix fun LongArray?.contentEquals(other: LongArray?): Boolean
@DeprecatedSinceKotlin(hiddenSince = "1.4")
infix fun ShortArray.contentEquals(other: ShortArray): Boolean
infix fun ShortArray?.contentEquals(other: ShortArray?): Boolean
infix fun UByteArray.contentEquals(other: UByteArray): Boolean
infix fun UByteArray?.contentEquals(other: UByteArray?): Boolean
infix fun UIntArray.contentEquals(other: UIntArray): Boolean
infix fun UIntArray?.contentEquals(other: UIntArray?): Boolean
infix fun ULongArray.contentEquals(other: ULongArray): Boolean
infix fun ULongArray?.contentEquals(other: ULongArray?): Boolean
infix fun UShortArray.contentEquals(other: UShortArray): Boolean
infix fun UShortArray?.contentEquals(other: UShortArray?): Boolean
Link copied to clipboard
@DeprecatedSinceKotlin(hiddenSince = "1.4")
fun <T> Array<out T>.contentHashCode(): Int
fun <T> Array<out T>?.contentHashCode(): Int
@DeprecatedSinceKotlin(hiddenSince = "1.4")
fun BooleanArray.contentHashCode(): Int
fun BooleanArray?.contentHashCode(): Int
@DeprecatedSinceKotlin(hiddenSince = "1.4")
fun ByteArray.contentHashCode(): Int
fun ByteArray?.contentHashCode(): Int
@DeprecatedSinceKotlin(hiddenSince = "1.4")
fun CharArray.contentHashCode(): Int
fun CharArray?.contentHashCode(): Int
@DeprecatedSinceKotlin(hiddenSince = "1.4")
fun DoubleArray.contentHashCode(): Int
fun DoubleArray?.contentHashCode(): Int
@DeprecatedSinceKotlin(hiddenSince = "1.4")
fun FloatArray.contentHashCode(): Int
fun FloatArray?.contentHashCode(): Int
@DeprecatedSinceKotlin(hiddenSince = "1.4")
fun IntArray.contentHashCode(): Int
fun IntArray?.contentHashCode(): Int
@DeprecatedSinceKotlin(hiddenSince = "1.4")
fun LongArray.contentHashCode(): Int
fun LongArray?.contentHashCode(): Int
@DeprecatedSinceKotlin(hiddenSince = "1.4")
fun ShortArray.contentHashCode(): Int
fun ShortArray?.contentHashCode(): Int
fun UByteArray.contentHashCode(): Int
fun UByteArray?.contentHashCode(): Int
fun UIntArray.contentHashCode(): Int
fun UIntArray?.contentHashCode(): Int
fun ULongArray.contentHashCode(): Int
fun ULongArray?.contentHashCode(): Int
fun UShortArray.contentHashCode(): Int
fun UShortArray?.contentHashCode(): Int
Link copied to clipboard
@DeprecatedSinceKotlin(hiddenSince = "1.4")
fun <T> Array<out T>.contentToString(): String
fun <T> Array<out T>?.contentToString(): String
@DeprecatedSinceKotlin(hiddenSince = "1.4")
fun BooleanArray.contentToString(): String
fun BooleanArray?.contentToString(): String
@DeprecatedSinceKotlin(hiddenSince = "1.4")
fun ByteArray.contentToString(): String
fun ByteArray?.contentToString(): String
@DeprecatedSinceKotlin(hiddenSince = "1.4")
fun CharArray.contentToString(): String
fun CharArray?.contentToString(): String
@DeprecatedSinceKotlin(hiddenSince = "1.4")
fun DoubleArray.contentToString(): String
fun DoubleArray?.contentToString(): String
@DeprecatedSinceKotlin(hiddenSince = "1.4")
fun FloatArray.contentToString(): String
fun FloatArray?.contentToString(): String
@DeprecatedSinceKotlin(hiddenSince = "1.4")
fun IntArray.contentToString(): String
fun IntArray?.contentToString(): String
@DeprecatedSinceKotlin(hiddenSince = "1.4")
fun LongArray.contentToString(): String
fun LongArray?.contentToString(): String
@DeprecatedSinceKotlin(hiddenSince = "1.4")
fun ShortArray.contentToString(): String
fun ShortArray?.contentToString(): String
fun UByteArray.contentToString(): String
fun UByteArray?.contentToString(): String
fun UIntArray.contentToString(): String
fun UIntArray?.contentToString(): String
fun ULongArray.contentToString(): String
fun ULongArray?.contentToString(): String
fun UShortArray.contentToString(): String
fun UShortArray?.contentToString(): String
Link copied to clipboard
inline fun <T> Array<out T>.copyInto(destination: Array<T>, destinationOffset: Int)
inline fun BooleanArray.copyInto(destination: BooleanArray, destinationOffset: Int)
inline fun ByteArray.copyInto(destination: ByteArray, destinationOffset: Int)
inline fun CharArray.copyInto(destination: CharArray, destinationOffset: Int)
inline fun DoubleArray.copyInto(destination: DoubleArray, destinationOffset: Int)
inline fun FloatArray.copyInto(destination: FloatArray, destinationOffset: Int)
inline fun IntArray.copyInto(destination: IntArray, destinationOffset: Int)
inline fun LongArray.copyInto(destination: LongArray, destinationOffset: Int)
inline fun ShortArray.copyInto(destination: ShortArray, destinationOffset: Int)
inline fun UByteArray.copyInto(destination: UByteArray, destinationOffset: Int)
inline fun UIntArray.copyInto(destination: UIntArray, destinationOffset: Int)
inline fun ULongArray.copyInto(destination: ULongArray, destinationOffset: Int)
inline fun UShortArray.copyInto(destination: UShortArray, destinationOffset: Int)
Link copied to clipboard
inline fun <T> Array<out T>.copyOf(): Array<T>
fun BooleanArray.copyOf(): BooleanArray
inline fun ByteArray.copyOf(): ByteArray
fun CharArray.copyOf(): CharArray
inline fun DoubleArray.copyOf(): DoubleArray
inline fun FloatArray.copyOf(): FloatArray
inline fun IntArray.copyOf(): IntArray
fun LongArray.copyOf(): LongArray
inline fun ShortArray.copyOf(): ShortArray
inline fun UByteArray.copyOf(): UByteArray
inline fun UIntArray.copyOf(): UIntArray
inline fun ULongArray.copyOf(): ULongArray
inline fun UShortArray.copyOf(): UShortArray
fun <T> Array<out T>.copyOf(newSize: Int): Array<T?>
fun BooleanArray.copyOf(newSize: Int): BooleanArray
fun ByteArray.copyOf(newSize: Int): ByteArray
fun CharArray.copyOf(newSize: Int): CharArray
fun DoubleArray.copyOf(newSize: Int): DoubleArray
fun FloatArray.copyOf(newSize: Int): FloatArray
fun IntArray.copyOf(newSize: Int): IntArray
fun LongArray.copyOf(newSize: Int): LongArray
fun ShortArray.copyOf(newSize: Int): ShortArray
inline fun UByteArray.copyOf(newSize: Int): UByteArray
inline fun UIntArray.copyOf(newSize: Int): UIntArray
inline fun ULongArray.copyOf(newSize: Int): ULongArray
inline fun UShortArray.copyOf(newSize: Int): UShortArray
Link copied to clipboard
fun <T> Array<out T>.copyOfRange(fromIndex: Int, toIndex: Int): Array<T>
fun BooleanArray.copyOfRange(fromIndex: Int, toIndex: Int): BooleanArray
fun ByteArray.copyOfRange(fromIndex: Int, toIndex: Int): ByteArray
fun CharArray.copyOfRange(fromIndex: Int, toIndex: Int): CharArray
fun DoubleArray.copyOfRange(fromIndex: Int, toIndex: Int): DoubleArray
fun FloatArray.copyOfRange(fromIndex: Int, toIndex: Int): FloatArray
fun IntArray.copyOfRange(fromIndex: Int, toIndex: Int): IntArray
fun LongArray.copyOfRange(fromIndex: Int, toIndex: Int): LongArray
fun ShortArray.copyOfRange(fromIndex: Int, toIndex: Int): ShortArray
inline fun UByteArray.copyOfRange(fromIndex: Int, toIndex: Int): UByteArray
inline fun UIntArray.copyOfRange(fromIndex: Int, toIndex: Int): UIntArray
inline fun ULongArray.copyOfRange(fromIndex: Int, toIndex: Int): ULongArray
inline fun UShortArray.copyOfRange(fromIndex: Int, toIndex: Int): UShortArray
Link copied to clipboard
inline fun <T> Array<out T>.count(): Int
inline fun BooleanArray.count(): Int
inline fun ByteArray.count(): Int
inline fun CharArray.count(): Int
inline fun DoubleArray.count(): Int
inline fun FloatArray.count(): Int
inline fun IntArray.count(): Int
inline fun LongArray.count(): Int
inline fun ShortArray.count(): Int
inline fun <T> Collection<T>.count(): Int
fun <T> Iterable<T>.count(): Int
inline fun <K, V> Map<out K, V>.count(): Int
inline fun <T> Array<out T>.count(predicate: (T) -> Boolean): Int
inline fun BooleanArray.count(predicate: (Boolean) -> Boolean): Int
inline fun ByteArray.count(predicate: (Byte) -> Boolean): Int
inline fun CharArray.count(predicate: (Char) -> Boolean): Int
inline fun DoubleArray.count(predicate: (Double) -> Boolean): Int
inline fun FloatArray.count(predicate: (Float) -> Boolean): Int
inline fun IntArray.count(predicate: (Int) -> Boolean): Int
inline fun LongArray.count(predicate: (Long) -> Boolean): Int
inline fun ShortArray.count(predicate: (Short) -> Boolean): Int
inline fun UByteArray.count(predicate: (UByte) -> Boolean): Int
inline fun UIntArray.count(predicate: (UInt) -> Boolean): Int
inline fun ULongArray.count(predicate: (ULong) -> Boolean): Int
inline fun UShortArray.count(predicate: (UShort) -> Boolean): Int
inline fun <T> Iterable<T>.count(predicate: (T) -> Boolean): Int
inline fun <K, V> Map<out K, V>.count(predicate: (Map.Entry<K, V>) -> Boolean): Int
Link copied to clipboard
fun <T> Array<out T>.distinct(): List<T>
fun BooleanArray.distinct(): List<Boolean>
fun ByteArray.distinct(): List<Byte>
fun CharArray.distinct(): List<Char>
fun DoubleArray.distinct(): List<Double>
fun FloatArray.distinct(): List<Float>
fun IntArray.distinct(): List<Int>
fun LongArray.distinct(): List<Long>
fun ShortArray.distinct(): List<Short>
fun <T> Iterable<T>.distinct(): List<T>
Link copied to clipboard
inline fun <T, K> Array<out T>.distinctBy(selector: (T) -> K): List<T>
inline fun <K> BooleanArray.distinctBy(selector: (Boolean) -> K): List<Boolean>
inline fun <K> ByteArray.distinctBy(selector: (Byte) -> K): List<Byte>
inline fun <K> CharArray.distinctBy(selector: (Char) -> K): List<Char>
inline fun <K> DoubleArray.distinctBy(selector: (Double) -> K): List<Double>
inline fun <K> FloatArray.distinctBy(selector: (Float) -> K): List<Float>
inline fun <K> IntArray.distinctBy(selector: (Int) -> K): List<Int>
inline fun <K> LongArray.distinctBy(selector: (Long) -> K): List<Long>
inline fun <K> ShortArray.distinctBy(selector: (Short) -> K): List<Short>
inline fun <T, K> Iterable<T>.distinctBy(selector: (T) -> K): List<T>
Link copied to clipboard
fun <T> Array<out T>.drop(n: Int): List<T>
fun BooleanArray.drop(n: Int): List<Boolean>
fun ByteArray.drop(n: Int): List<Byte>
fun CharArray.drop(n: Int): List<Char>
fun DoubleArray.drop(n: Int): List<Double>
fun FloatArray.drop(n: Int): List<Float>
fun IntArray.drop(n: Int): List<Int>
fun LongArray.drop(n: Int): List<Long>
fun ShortArray.drop(n: Int): List<Short>
fun UByteArray.drop(n: Int): List<UByte>
fun UIntArray.drop(n: Int): List<UInt>
fun ULongArray.drop(n: Int): List<ULong>
fun UShortArray.drop(n: Int): List<UShort>
fun <T> Iterable<T>.drop(n: Int): List<T>
Link copied to clipboard
fun <T> Array<out T>.dropLast(n: Int): List<T>
fun BooleanArray.dropLast(n: Int): List<Boolean>
fun ByteArray.dropLast(n: Int): List<Byte>
fun CharArray.dropLast(n: Int): List<Char>
fun DoubleArray.dropLast(n: Int): List<Double>
fun FloatArray.dropLast(n: Int): List<Float>
fun IntArray.dropLast(n: Int): List<Int>
fun LongArray.dropLast(n: Int): List<Long>
fun ShortArray.dropLast(n: Int): List<Short>
fun UByteArray.dropLast(n: Int): List<UByte>
fun UIntArray.dropLast(n: Int): List<UInt>
fun ULongArray.dropLast(n: Int): List<ULong>
fun UShortArray.dropLast(n: Int): List<UShort>
fun <T> List<T>.dropLast(n: Int): List<T>
Link copied to clipboard
inline fun <T> Array<out T>.dropLastWhile(predicate: (T) -> Boolean): List<T>
inline fun BooleanArray.dropLastWhile(predicate: (Boolean) -> Boolean): List<Boolean>
inline fun ByteArray.dropLastWhile(predicate: (Byte) -> Boolean): List<Byte>
inline fun CharArray.dropLastWhile(predicate: (Char) -> Boolean): List<Char>
inline fun DoubleArray.dropLastWhile(predicate: (Double) -> Boolean): List<Double>
inline fun FloatArray.dropLastWhile(predicate: (Float) -> Boolean): List<Float>
inline fun IntArray.dropLastWhile(predicate: (Int) -> Boolean): List<Int>
inline fun LongArray.dropLastWhile(predicate: (Long) -> Boolean): List<Long>
inline fun ShortArray.dropLastWhile(predicate: (Short) -> Boolean): List<Short>
inline fun UByteArray.dropLastWhile(predicate: (UByte) -> Boolean): List<UByte>
inline fun UIntArray.dropLastWhile(predicate: (UInt) -> Boolean): List<UInt>
inline fun ULongArray.dropLastWhile(predicate: (ULong) -> Boolean): List<ULong>
inline fun UShortArray.dropLastWhile(predicate: (UShort) -> Boolean): List<UShort>
inline fun <T> List<T>.dropLastWhile(predicate: (T) -> Boolean): List<T>
Link copied to clipboard
inline fun <T> Array<out T>.dropWhile(predicate: (T) -> Boolean): List<T>
inline fun BooleanArray.dropWhile(predicate: (Boolean) -> Boolean): List<Boolean>
inline fun ByteArray.dropWhile(predicate: (Byte) -> Boolean): List<Byte>
inline fun CharArray.dropWhile(predicate: (Char) -> Boolean): List<Char>
inline fun DoubleArray.dropWhile(predicate: (Double) -> Boolean): List<Double>
inline fun FloatArray.dropWhile(predicate: (Float) -> Boolean): List<Float>
inline fun IntArray.dropWhile(predicate: (Int) -> Boolean): List<Int>
inline fun LongArray.dropWhile(predicate: (Long) -> Boolean): List<Long>
inline fun ShortArray.dropWhile(predicate: (Short) -> Boolean): List<Short>
inline fun UByteArray.dropWhile(predicate: (UByte) -> Boolean): List<UByte>
inline fun UIntArray.dropWhile(predicate: (UInt) -> Boolean): List<UInt>
inline fun ULongArray.dropWhile(predicate: (ULong) -> Boolean): List<ULong>
inline fun UShortArray.dropWhile(predicate: (UShort) -> Boolean): List<UShort>
inline fun <T> Iterable<T>.dropWhile(predicate: (T) -> Boolean): List<T>
Link copied to clipboard
fun <T, K> Grouping<T, K>.eachCount(): Map<K, Int>
Link copied to clipboard
fun <T, K, M : MutableMap<in K, Int>> Grouping<T, K>.eachCountTo(destination: M): M
Link copied to clipboard
fun <T> Array<out T>.elementAt(index: Int): T
fun BooleanArray.elementAt(index: Int): Boolean
fun ByteArray.elementAt(index: Int): Byte
fun CharArray.elementAt(index: Int): Char
fun DoubleArray.elementAt(index: Int): Double
fun FloatArray.elementAt(index: Int): Float
fun IntArray.elementAt(index: Int): Int
fun LongArray.elementAt(index: Int): Long
fun ShortArray.elementAt(index: Int): Short
fun UByteArray.elementAt(index: Int): UByte
fun UIntArray.elementAt(index: Int): UInt
fun ULongArray.elementAt(index: Int): ULong
fun UShortArray.elementAt(index: Int): UShort
fun <T> Iterable<T>.elementAt(index: Int): T
inline fun <T> List<T>.elementAt(index: Int): T
Link copied to clipboard
inline fun <T> Array<out T>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): T
inline fun BooleanArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Boolean): Boolean
inline fun ByteArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Byte): Byte
inline fun CharArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Char): Char
inline fun DoubleArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Double): Double
inline fun FloatArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Float): Float
inline fun IntArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Int): Int
inline fun LongArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Long): Long
inline fun ShortArray.elementAtOrElse(index: Int, defaultValue: (Int) -> Short): Short
inline fun UByteArray.elementAtOrElse(index: Int, defaultValue: (Int) -> UByte): UByte
inline fun UIntArray.elementAtOrElse(index: Int, defaultValue: (Int) -> UInt): UInt
inline fun ULongArray.elementAtOrElse(index: Int, defaultValue: (Int) -> ULong): ULong
inline fun UShortArray.elementAtOrElse(index: Int, defaultValue: (Int) -> UShort): UShort
fun <T> Iterable<T>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): T
inline fun <T> List<T>.elementAtOrElse(index: Int, defaultValue: (Int) -> T): T
Link copied to clipboard
inline fun <T> Array<out T>.elementAtOrNull(index: Int): T?
inline fun BooleanArray.elementAtOrNull(index: Int): Boolean?
inline fun ByteArray.elementAtOrNull(index: Int): Byte?
inline fun CharArray.elementAtOrNull(index: Int): Char?
inline fun DoubleArray.elementAtOrNull(index: Int): Double?
inline fun FloatArray.elementAtOrNull(index: Int): Float?
inline fun IntArray.elementAtOrNull(index: Int): Int?
inline fun LongArray.elementAtOrNull(index: Int): Long?
inline fun ShortArray.elementAtOrNull(index: Int): Short?
inline fun UByteArray.elementAtOrNull(index: Int): UByte?
inline fun UIntArray.elementAtOrNull(index: Int): UInt?
inline fun ULongArray.elementAtOrNull(index: Int): ULong?
inline fun UShortArray.elementAtOrNull(index: Int): UShort?
fun <T> Iterable<T>.elementAtOrNull(index: Int): T?
inline fun <T> List<T>.elementAtOrNull(index: Int): T?
Link copied to clipboard
fun <T> emptyList(): List<T>
Link copied to clipboard
fun <K, V> emptyMap(): Map<K, V>
Link copied to clipboard
fun <T> emptySet(): Set<T>
Link copied to clipboard
fun <T> MutableList<T>.fill(value: T)
fun <T> Array<T>.fill(element: T, fromIndex: Int)
fun BooleanArray.fill(element: Boolean, fromIndex: Int)
fun ByteArray.fill(element: Byte, fromIndex: Int)
fun CharArray.fill(element: Char, fromIndex: Int)
fun DoubleArray.fill(element: Double, fromIndex: Int)
fun FloatArray.fill(element: Float, fromIndex: Int)
fun IntArray.fill(element: Int, fromIndex: Int)
fun LongArray.fill(element: Long, fromIndex: Int)
fun ShortArray.fill(element: Short, fromIndex: Int)
fun UByteArray.fill(element: UByte, fromIndex: Int)
fun UIntArray.fill(element: UInt, fromIndex: Int)
fun ULongArray.fill(element: ULong, fromIndex: Int)
fun UShortArray.fill(element: UShort, fromIndex: Int)
Link copied to clipboard
inline fun <T> Array<out T>.filter(predicate: (T) -> Boolean): List<T>
inline fun BooleanArray.filter(predicate: (Boolean) -> Boolean): List<Boolean>
inline fun ByteArray.filter(predicate: (Byte) -> Boolean): List<Byte>
inline fun CharArray.filter(predicate: (Char) -> Boolean): List<Char>
inline fun DoubleArray.filter(predicate: (Double) -> Boolean): List<Double>
inline fun FloatArray.filter(predicate: (Float) -> Boolean): List<Float>
inline fun IntArray.filter(predicate: (Int) -> Boolean): List<Int>
inline fun LongArray.filter(predicate: (Long) -> Boolean): List<Long>
inline fun ShortArray.filter(predicate: (Short) -> Boolean): List<Short>
inline fun UByteArray.filter(predicate: (UByte) -> Boolean): List<UByte>
inline fun UIntArray.filter(predicate: (UInt) -> Boolean): List<UInt>
inline fun ULongArray.filter(predicate: (ULong) -> Boolean): List<ULong>
inline fun UShortArray.filter(predicate: (UShort) -> Boolean): List<UShort>
inline fun <T> Iterable<T>.filter(predicate: (T) -> Boolean): List<T>
inline fun <K, V> Map<out K, V>.filter(predicate: (Map.Entry<K, V>) -> Boolean): Map<K, V>
Link copied to clipboard
inline fun <T> Array<out T>.filterIndexed(predicate: (index: Int, T) -> Boolean): List<T>
inline fun BooleanArray.filterIndexed(predicate: (index: Int, Boolean) -> Boolean): List<Boolean>
inline fun ByteArray.filterIndexed(predicate: (index: Int, Byte) -> Boolean): List<Byte>
inline fun CharArray.filterIndexed(predicate: (index: Int, Char) -> Boolean): List<Char>
inline fun DoubleArray.filterIndexed(predicate: (index: Int, Double) -> Boolean): List<Double>
inline fun FloatArray.filterIndexed(predicate: (index: Int, Float) -> Boolean): List<Float>
inline fun IntArray.filterIndexed(predicate: (index: Int, Int) -> Boolean): List<Int>
inline fun LongArray.filterIndexed(predicate: (index: Int, Long) -> Boolean): List<Long>
inline fun ShortArray.filterIndexed(predicate: (index: Int, Short) -> Boolean): List<Short>
inline fun UByteArray.filterIndexed(predicate: (index: Int, UByte) -> Boolean): List<UByte>
inline fun UIntArray.filterIndexed(predicate: (index: Int, UInt) -> Boolean): List<UInt>
inline fun ULongArray.filterIndexed(predicate: (index: Int, ULong) -> Boolean): List<ULong>
inline fun UShortArray.filterIndexed(predicate: (index: Int, UShort) -> Boolean): List<UShort>
inline fun <T> Iterable<T>.filterIndexed(predicate: (index: Int, T) -> Boolean): List<T>
Link copied to clipboard
inline fun <T, C : MutableCollection<in T>> Array<out T>.filterIndexedTo(destination: C, predicate: (index: Int, T) -> Boolean): C
inline fun <C : MutableCollection<in Boolean>> BooleanArray.filterIndexedTo(destination: C, predicate: (index: Int, Boolean) -> Boolean): C
inline fun <C : MutableCollection<in Byte>> ByteArray.filterIndexedTo(destination: C, predicate: (index: Int, Byte) -> Boolean): C
inline fun <C : MutableCollection<in Char>> CharArray.filterIndexedTo(destination: C, predicate: (index: Int, Char) -> Boolean): C
inline fun <C : MutableCollection<in Double>> DoubleArray.filterIndexedTo(destination: C, predicate: (index: Int, Double) -> Boolean): C
inline fun <C : MutableCollection<in Float>> FloatArray.filterIndexedTo(destination: C, predicate: (index: Int, Float) -> Boolean): C
inline fun <C : MutableCollection<in Int>> IntArray.filterIndexedTo(destination: C, predicate: (index: Int, Int) -> Boolean): C
inline fun <C : MutableCollection<in Long>> LongArray.filterIndexedTo(destination: C, predicate: (index: Int, Long) -> Boolean): C
inline fun <C : MutableCollection<in Short>> ShortArray.filterIndexedTo(destination: C, predicate: (index: Int, Short) -> Boolean): C
inline fun <C : MutableCollection<in UByte>> UByteArray.filterIndexedTo(destination: C, predicate: (index: Int, UByte) -> Boolean): C
inline fun <C : MutableCollection<in UInt>> UIntArray.filterIndexedTo(destination: C, predicate: (index: Int, UInt) -> Boolean): C
inline fun <C : MutableCollection<in ULong>> ULongArray.filterIndexedTo(destination: C, predicate: (index: Int, ULong) -> Boolean): C
inline fun <C : MutableCollection<in UShort>> UShortArray.filterIndexedTo(destination: C, predicate: (index: Int, UShort) -> Boolean): C
inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterIndexedTo(destination: C, predicate: (index: Int, T) -> Boolean): C
Link copied to clipboard
inline fun <R> Array<*>.filterIsInstance(): List<R>
inline fun <R> Iterable<*>.filterIsInstance(): List<R>
Link copied to clipboard
inline fun <R, C : MutableCollection<in R>> Array<*>.filterIsInstanceTo(destination: C): C
inline fun <R, C : MutableCollection<in R>> Iterable<*>.filterIsInstanceTo(destination: C): C
Link copied to clipboard
inline fun <K, V> Map<out K, V>.filterKeys(predicate: (K) -> Boolean): Map<K, V>
Link copied to clipboard
inline fun <T> Array<out T>.filterNot(predicate: (T) -> Boolean): List<T>
inline fun BooleanArray.filterNot(predicate: (Boolean) -> Boolean): List<Boolean>
inline fun ByteArray.filterNot(predicate: (Byte) -> Boolean): List<Byte>
inline fun CharArray.filterNot(predicate: (Char) -> Boolean): List<Char>
inline fun DoubleArray.filterNot(predicate: (Double) -> Boolean): List<Double>
inline fun FloatArray.filterNot(predicate: (Float) -> Boolean): List<Float>
inline fun IntArray.filterNot(predicate: (Int) -> Boolean): List<Int>
inline fun LongArray.filterNot(predicate: (Long) -> Boolean): List<Long>
inline fun ShortArray.filterNot(predicate: (Short) -> Boolean): List<Short>
inline fun UByteArray.filterNot(predicate: (UByte) -> Boolean): List<UByte>
inline fun UIntArray.filterNot(predicate: (UInt) -> Boolean): List<UInt>
inline fun ULongArray.filterNot(predicate: (ULong) -> Boolean): List<ULong>
inline fun UShortArray.filterNot(predicate: (UShort) -> Boolean): List<UShort>
inline fun <T> Iterable<T>.filterNot(predicate: (T) -> Boolean): List<T>
inline fun <K, V> Map<out K, V>.filterNot(predicate: (Map.Entry<K, V>) -> Boolean): Map<K, V>
Link copied to clipboard
fun <T : Any> Array<out T?>.filterNotNull(): List<T>
fun <T : Any> Iterable<T?>.filterNotNull(): List<T>
Link copied to clipboard
fun <C : MutableCollection<in T>, T : Any> Array<out T?>.filterNotNullTo(destination: C): C
fun <C : MutableCollection<in T>, T : Any> Iterable<T?>.filterNotNullTo(destination: C): C
Link copied to clipboard
inline fun <T, C : MutableCollection<in T>> Array<out T>.filterNotTo(destination: C, predicate: (T) -> Boolean): C
inline fun <C : MutableCollection<in Boolean>> BooleanArray.filterNotTo(destination: C, predicate: (Boolean) -> Boolean): C
inline fun <C : MutableCollection<in Byte>> ByteArray.filterNotTo(destination: C, predicate: (Byte) -> Boolean): C
inline fun <C : MutableCollection<in Char>> CharArray.filterNotTo(destination: C, predicate: (Char) -> Boolean): C
inline fun <C : MutableCollection<in Double>> DoubleArray.filterNotTo(destination: C, predicate: (Double) -> Boolean): C
inline fun <C : MutableCollection<in Float>> FloatArray.filterNotTo(destination: C, predicate: (Float) -> Boolean): C
inline fun <C : MutableCollection<in Int>> IntArray.filterNotTo(destination: C, predicate: (Int) -> Boolean): C
inline fun <C : MutableCollection<in Long>> LongArray.filterNotTo(destination: C, predicate: (Long) -> Boolean): C
inline fun <C : MutableCollection<in Short>> ShortArray.filterNotTo(destination: C, predicate: (Short) -> Boolean): C
inline fun <C : MutableCollection<in UByte>> UByteArray.filterNotTo(destination: C, predicate: (UByte) -> Boolean): C
inline fun <C : MutableCollection<in UInt>> UIntArray.filterNotTo(destination: C, predicate: (UInt) -> Boolean): C
inline fun <C : MutableCollection<in ULong>> ULongArray.filterNotTo(destination: C, predicate: (ULong) -> Boolean): C
inline fun <C : MutableCollection<in UShort>> UShortArray.filterNotTo(destination: C, predicate: (UShort) -> Boolean): C
inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterNotTo(destination: C, predicate: (T) -> Boolean): C
inline fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.filterNotTo(destination: M, predicate: (Map.Entry<K, V>) -> Boolean): M
Link copied to clipboard
inline fun <T, C : MutableCollection<in T>> Array<out T>.filterTo(destination: C, predicate: (T) -> Boolean): C
inline fun <C : MutableCollection<in Boolean>> BooleanArray.filterTo(destination: C, predicate: (Boolean) -> Boolean): C
inline fun <C : MutableCollection<in Byte>> ByteArray.filterTo(destination: C, predicate: (Byte) -> Boolean): C
inline fun <C : MutableCollection<in Char>> CharArray.filterTo(destination: C, predicate: (Char) -> Boolean): C
inline fun <C : MutableCollection<in Double>> DoubleArray.filterTo(destination: C, predicate: (Double) -> Boolean): C
inline fun <C : MutableCollection<in Float>> FloatArray.filterTo(destination: C, predicate: (Float) -> Boolean): C
inline fun <C : MutableCollection<in Int>> IntArray.filterTo(destination: C, predicate: (Int) -> Boolean): C
inline fun <C : MutableCollection<in Long>> LongArray.filterTo(destination: C, predicate: (Long) -> Boolean): C
inline fun <C : MutableCollection<in Short>> ShortArray.filterTo(destination: C, predicate: (Short) -> Boolean): C
inline fun <C : MutableCollection<in UByte>> UByteArray.filterTo(destination: C, predicate: (UByte) -> Boolean): C
inline fun <C : MutableCollection<in UInt>> UIntArray.filterTo(destination: C, predicate: (UInt) -> Boolean): C
inline fun <C : MutableCollection<in ULong>> ULongArray.filterTo(destination: C, predicate: (ULong) -> Boolean): C
inline fun <C : MutableCollection<in UShort>> UShortArray.filterTo(destination: C, predicate: (UShort) -> Boolean): C
inline fun <T, C : MutableCollection<in T>> Iterable<T>.filterTo(destination: C, predicate: (T) -> Boolean): C
inline fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.filterTo(destination: M, predicate: (Map.Entry<K, V>) -> Boolean): M
Link copied to clipboard
inline fun <K, V> Map<out K, V>.filterValues(predicate: (V) -> Boolean): Map<K, V>
Link copied to clipboard
inline fun <T> Array<out T>.find(predicate: (T) -> Boolean): T?
inline fun BooleanArray.find(predicate: (Boolean) -> Boolean): Boolean?
inline fun ByteArray.find(predicate: (Byte) -> Boolean): Byte?
inline fun CharArray.find(predicate: (Char) -> Boolean): Char?
inline fun DoubleArray.find(predicate: (Double) -> Boolean): Double?
inline fun FloatArray.find(predicate: (Float) -> Boolean): Float?
inline fun IntArray.find(predicate: (Int) -> Boolean): Int?
inline fun LongArray.find(predicate: (Long) -> Boolean): Long?
inline fun ShortArray.find(predicate: (Short) -> Boolean): Short?
inline fun UByteArray.find(predicate: (UByte) -> Boolean): UByte?
inline fun UIntArray.find(predicate: (UInt) -> Boolean): UInt?
inline fun ULongArray.find(predicate: (ULong) -> Boolean): ULong?
inline fun UShortArray.find(predicate: (UShort) -> Boolean): UShort?
inline fun <T> Iterable<T>.find(predicate: (T) -> Boolean): T?
Link copied to clipboard
inline fun <T> Array<out T>.findLast(predicate: (T) -> Boolean): T?
inline fun BooleanArray.findLast(predicate: (Boolean) -> Boolean): Boolean?
inline fun ByteArray.findLast(predicate: (Byte) -> Boolean): Byte?
inline fun CharArray.findLast(predicate: (Char) -> Boolean): Char?
inline fun DoubleArray.findLast(predicate: (Double) -> Boolean): Double?
inline fun FloatArray.findLast(predicate: (Float) -> Boolean): Float?
inline fun IntArray.findLast(predicate: (Int) -> Boolean): Int?
inline fun LongArray.findLast(predicate: (Long) -> Boolean): Long?
inline fun ShortArray.findLast(predicate: (Short) -> Boolean): Short?
inline fun UByteArray.findLast(predicate: (UByte) -> Boolean): UByte?
inline fun UIntArray.findLast(predicate: (UInt) -> Boolean): UInt?
inline fun ULongArray.findLast(predicate: (ULong) -> Boolean): ULong?
inline fun UShortArray.findLast(predicate: (UShort) -> Boolean): UShort?
inline fun <T> Iterable<T>.findLast(predicate: (T) -> Boolean): T?
inline fun <T> List<T>.findLast(predicate: (T) -> Boolean): T?
Link copied to clipboard
fun <T> Array<out T>.first(): T
fun BooleanArray.first(): Boolean
fun ByteArray.first(): Byte
fun CharArray.first(): Char
fun DoubleArray.first(): Double
fun FloatArray.first(): Float
fun IntArray.first(): Int
fun LongArray.first(): Long
fun ShortArray.first(): Short
inline fun UByteArray.first(): UByte
inline fun UIntArray.first(): UInt
inline fun ULongArray.first(): ULong
inline fun UShortArray.first(): UShort
fun <T> Iterable<T>.first(): T
fun <T> List<T>.first(): T
inline fun <T> Array<out T>.first(predicate: (T) -> Boolean): T
inline fun BooleanArray.first(predicate: (Boolean) -> Boolean): Boolean
inline fun ByteArray.first(predicate: (Byte) -> Boolean): Byte
inline fun CharArray.first(predicate: (Char) -> Boolean): Char
inline fun DoubleArray.first(predicate: (Double) -> Boolean): Double
inline fun FloatArray.first(predicate: (Float) -> Boolean): Float
inline fun IntArray.first(predicate: (Int) -> Boolean): Int
inline fun LongArray.first(predicate: (Long) -> Boolean): Long
inline fun ShortArray.first(predicate: (Short) -> Boolean): Short
inline fun UByteArray.first(predicate: (UByte) -> Boolean): UByte
inline fun UIntArray.first(predicate: (UInt) -> Boolean): UInt
inline fun ULongArray.first(predicate: (ULong) -> Boolean): ULong
inline fun UShortArray.first(predicate: (UShort) -> Boolean): UShort
inline fun <T> Iterable<T>.first(predicate: (T) -> Boolean): T
Link copied to clipboard
inline fun <T, R : Any> Array<out T>.firstNotNullOf(transform: (T) -> R?): R
inline fun <T, R : Any> Iterable<T>.firstNotNullOf(transform: (T) -> R?): R
inline fun <K, V, R : Any> Map<out K, V>.firstNotNullOf(transform: (Map.Entry<K, V>) -> R?): R
Link copied to clipboard
inline fun <T, R : Any> Array<out T>.firstNotNullOfOrNull(transform: (T) -> R?): R?
inline fun <T, R : Any> Iterable<T>.firstNotNullOfOrNull(transform: (T) -> R?): R?
inline fun <K, V, R : Any> Map<out K, V>.firstNotNullOfOrNull(transform: (Map.Entry<K, V>) -> R?): R?
Link copied to clipboard
fun <T> Array<out T>.firstOrNull(): T?
fun BooleanArray.firstOrNull(): Boolean?
fun ByteArray.firstOrNull(): Byte?
fun CharArray.firstOrNull(): Char?
fun DoubleArray.firstOrNull(): Double?
fun FloatArray.firstOrNull(): Float?
fun IntArray.firstOrNull(): Int?
fun LongArray.firstOrNull(): Long?
fun ShortArray.firstOrNull(): Short?
fun UByteArray.firstOrNull(): UByte?
fun UIntArray.firstOrNull(): UInt?
fun ULongArray.firstOrNull(): ULong?
fun UShortArray.firstOrNull(): UShort?
fun <T> Iterable<T>.firstOrNull(): T?
fun <T> List<T>.firstOrNull(): T?
inline fun <T> Array<out T>.firstOrNull(predicate: (T) -> Boolean): T?
inline fun BooleanArray.firstOrNull(predicate: (Boolean) -> Boolean): Boolean?
inline fun ByteArray.firstOrNull(predicate: (Byte) -> Boolean): Byte?
inline fun CharArray.firstOrNull(predicate: (Char) -> Boolean): Char?
inline fun DoubleArray.firstOrNull(predicate: (Double) -> Boolean): Double?
inline fun FloatArray.firstOrNull(predicate: (Float) -> Boolean): Float?
inline fun IntArray.firstOrNull(predicate: (Int) -> Boolean): Int?
inline fun LongArray.firstOrNull(predicate: (Long) -> Boolean): Long?
inline fun ShortArray.firstOrNull(predicate: (Short) -> Boolean): Short?
inline fun UByteArray.firstOrNull(predicate: (UByte) -> Boolean): UByte?
inline fun UIntArray.firstOrNull(predicate: (UInt) -> Boolean): UInt?
inline fun ULongArray.firstOrNull(predicate: (ULong) -> Boolean): ULong?
inline fun UShortArray.firstOrNull(predicate: (UShort) -> Boolean): UShort?
inline fun <T> Iterable<T>.firstOrNull(predicate: (T) -> Boolean): T?
Link copied to clipboard
inline fun <T, R> Array<out T>.flatMap(transform: (T) -> Iterable<R>): List<R>
@JvmName(name = "flatMapSequence")
inline fun <T, R> Array<out T>.flatMap(transform: (T) -> Sequence<R>): List<R>
inline fun <R> BooleanArray.flatMap(transform: (Boolean) -> Iterable<R>): List<R>
inline fun <R> ByteArray.flatMap(transform: (Byte) -> Iterable<R>): List<R>
inline fun <R> CharArray.flatMap(transform: (Char) -> Iterable<R>): List<R>
inline fun <R> DoubleArray.flatMap(transform: (Double) -> Iterable<R>): List<R>
inline fun <R> FloatArray.flatMap(transform: (Float) -> Iterable<R>): List<R>
inline fun <R> IntArray.flatMap(transform: (Int) -> Iterable<R>): List<R>
inline fun <R> LongArray.flatMap(transform: (Long) -> Iterable<R>): List<R>
inline fun <R> ShortArray.flatMap(transform: (Short) -> Iterable<R>): List<R>
inline fun <R> UByteArray.flatMap(transform: (UByte) -> Iterable<R>): List<R>
inline fun <R> UIntArray.flatMap(transform: (UInt) -> Iterable<R>): List<R>
inline fun <R> ULongArray.flatMap(transform: (ULong) -> Iterable<R>): List<R>
inline fun <R> UShortArray.flatMap(transform: (UShort) -> Iterable<R>): List<R>
inline fun <T, R> Iterable<T>.flatMap(transform: (T) -> Iterable<R>): List<R>
@JvmName(name = "flatMapSequence")
inline fun <T, R> Iterable<T>.flatMap(transform: (T) -> Sequence<R>): List<R>
inline fun <K, V, R> Map<out K, V>.flatMap(transform: (Map.Entry<K, V>) -> Iterable<R>): List<R>
@JvmName(name = "flatMapSequence")
inline fun <K, V, R> Map<out K, V>.flatMap(transform: (Map.Entry<K, V>) -> Sequence<R>): List<R>
Link copied to clipboard
@JvmName(name = "flatMapIndexedIterable")
inline fun <T, R> Array<out T>.flatMapIndexed(transform: (index: Int, T) -> Iterable<R>): List<R>
@JvmName(name = "flatMapIndexedSequence")
inline fun <T, R> Array<out T>.flatMapIndexed(transform: (index: Int, T) -> Sequence<R>): List<R>
@JvmName(name = "flatMapIndexedIterable")
inline fun <R> BooleanArray.flatMapIndexed(transform: (index: Int, Boolean) -> Iterable<R>): List<R>
@JvmName(name = "flatMapIndexedIterable")
inline fun <R> ByteArray.flatMapIndexed(transform: (index: Int, Byte) -> Iterable<R>): List<R>
@JvmName(name = "flatMapIndexedIterable")
inline fun <R> CharArray.flatMapIndexed(transform: (index: Int, Char) -> Iterable<R>): List<R>
@JvmName(name = "flatMapIndexedIterable")
inline fun <R> DoubleArray.flatMapIndexed(transform: (index: Int, Double) -> Iterable<R>): List<R>
@JvmName(name = "flatMapIndexedIterable")
inline fun <R> FloatArray.flatMapIndexed(transform: (index: Int, Float) -> Iterable<R>): List<R>
@JvmName(name = "flatMapIndexedIterable")
inline fun <R> IntArray.flatMapIndexed(transform: (index: Int, Int) -> Iterable<R>): List<R>
@JvmName(name = "flatMapIndexedIterable")
inline fun <R> LongArray.flatMapIndexed(transform: (index: Int, Long) -> Iterable<R>): List<R>
@JvmName(name = "flatMapIndexedIterable")
inline fun <R> ShortArray.flatMapIndexed(transform: (index: Int, Short) -> Iterable<R>): List<R>
inline fun <R> UByteArray.flatMapIndexed(transform: (index: Int, UByte) -> Iterable<R>): List<R>
inline fun <R> UIntArray.flatMapIndexed(transform: (index: Int, UInt) -> Iterable<R>): List<R>
inline fun <R> ULongArray.flatMapIndexed(transform: (index: Int, ULong) -> Iterable<R>): List<R>
inline fun <R> UShortArray.flatMapIndexed(transform: (index: Int, UShort) -> Iterable<R>): List<R>
@JvmName(name = "flatMapIndexedIterable")
inline fun <T, R> Iterable<T>.flatMapIndexed(transform: (index: Int, T) -> Iterable<R>): List<R>
@JvmName(name = "flatMapIndexedSequence")
inline fun <T, R> Iterable<T>.flatMapIndexed(transform: (index: Int, T) -> Sequence<R>): List<R>
Link copied to clipboard
@JvmName(name = "flatMapIndexedIterableTo")
inline fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapIndexedTo(destination: C, transform: (index: Int, T) -> Iterable<R>): C
@JvmName(name = "flatMapIndexedSequenceTo")
inline fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapIndexedTo(destination: C, transform: (index: Int, T) -> Sequence<R>): C
@JvmName(name = "flatMapIndexedIterableTo")
inline fun <R, C : MutableCollection<in R>> BooleanArray.flatMapIndexedTo(destination: C, transform: (index: Int, Boolean) -> Iterable<R>): C
@JvmName(name = "flatMapIndexedIterableTo")
inline fun <R, C : MutableCollection<in R>> ByteArray.flatMapIndexedTo(destination: C, transform: (index: Int, Byte) -> Iterable<R>): C
@JvmName(name = "flatMapIndexedIterableTo")
inline fun <R, C : MutableCollection<in R>> CharArray.flatMapIndexedTo(destination: C, transform: (index: Int, Char) -> Iterable<R>): C
@JvmName(name = "flatMapIndexedIterableTo")
inline fun <R, C : MutableCollection<in R>> DoubleArray.flatMapIndexedTo(destination: C, transform: (index: Int, Double) -> Iterable<R>): C
@JvmName(name = "flatMapIndexedIterableTo")
inline fun <R, C : MutableCollection<in R>> FloatArray.flatMapIndexedTo(destination: C, transform: (index: Int, Float) -> Iterable<R>): C
@JvmName(name = "flatMapIndexedIterableTo")
inline fun <R, C : MutableCollection<in R>> IntArray.flatMapIndexedTo(destination: C, transform: (index: Int, Int) -> Iterable<R>): C
@JvmName(name = "flatMapIndexedIterableTo")
inline fun <R, C : MutableCollection<in R>> LongArray.flatMapIndexedTo(destination: C, transform: (index: Int, Long) -> Iterable<R>): C
@JvmName(name = "flatMapIndexedIterableTo")
inline fun <R, C : MutableCollection<in R>> ShortArray.flatMapIndexedTo(destination: C, transform: (index: Int, Short) -> Iterable<R>): C
inline fun <R, C : MutableCollection<in R>> UByteArray.flatMapIndexedTo(destination: C, transform: (index: Int, UByte) -> Iterable<R>): C
inline fun <R, C : MutableCollection<in R>> UIntArray.flatMapIndexedTo(destination: C, transform: (index: Int, UInt) -> Iterable<R>): C
inline fun <R, C : MutableCollection<in R>> ULongArray.flatMapIndexedTo(destination: C, transform: (index: Int, ULong) -> Iterable<R>): C
inline fun <R, C : MutableCollection<in R>> UShortArray.flatMapIndexedTo(destination: C, transform: (index: Int, UShort) -> Iterable<R>): C
@JvmName(name = "flatMapIndexedIterableTo")
inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapIndexedTo(destination: C, transform: (index: Int, T) -> Iterable<R>): C
@JvmName(name = "flatMapIndexedSequenceTo")
inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapIndexedTo(destination: C, transform: (index: Int, T) -> Sequence<R>): C
Link copied to clipboard
inline fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapTo(destination: C, transform: (T) -> Iterable<R>): C
@JvmName(name = "flatMapSequenceTo")
inline fun <T, R, C : MutableCollection<in R>> Array<out T>.flatMapTo(destination: C, transform: (T) -> Sequence<R>): C
inline fun <R, C : MutableCollection<in R>> BooleanArray.flatMapTo(destination: C, transform: (Boolean) -> Iterable<R>): C
inline fun <R, C : MutableCollection<in R>> ByteArray.flatMapTo(destination: C, transform: (Byte) -> Iterable<R>): C
inline fun <R, C : MutableCollection<in R>> CharArray.flatMapTo(destination: C, transform: (Char) -> Iterable<R>): C
inline fun <R, C : MutableCollection<in R>> DoubleArray.flatMapTo(destination: C, transform: (Double) -> Iterable<R>): C
inline fun <R, C : MutableCollection<in R>> FloatArray.flatMapTo(destination: C, transform: (Float) -> Iterable<R>): C
inline fun <R, C : MutableCollection<in R>> IntArray.flatMapTo(destination: C, transform: (Int) -> Iterable<R>): C
inline fun <R, C : MutableCollection<in R>> LongArray.flatMapTo(destination: C, transform: (Long) -> Iterable<R>): C
inline fun <R, C : MutableCollection<in R>> ShortArray.flatMapTo(destination: C, transform: (Short) -> Iterable<R>): C
inline fun <R, C : MutableCollection<in R>> UByteArray.flatMapTo(destination: C, transform: (UByte) -> Iterable<R>): C
inline fun <R, C : MutableCollection<in R>> UIntArray.flatMapTo(destination: C, transform: (UInt) -> Iterable<R>): C
inline fun <R, C : MutableCollection<in R>> ULongArray.flatMapTo(destination: C, transform: (ULong) -> Iterable<R>): C
inline fun <R, C : MutableCollection<in R>> UShortArray.flatMapTo(destination: C, transform: (UShort) -> Iterable<R>): C
inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapTo(destination: C, transform: (T) -> Iterable<R>): C
@JvmName(name = "flatMapSequenceTo")
inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.flatMapTo(destination: C, transform: (T) -> Sequence<R>): C
inline fun <K, V, R, C : MutableCollection<in R>> Map<out K, V>.flatMapTo(destination: C, transform: (Map.Entry<K, V>) -> Iterable<R>): C
@JvmName(name = "flatMapSequenceTo")
inline fun <K, V, R, C : MutableCollection<in R>> Map<out K, V>.flatMapTo(destination: C, transform: (Map.Entry<K, V>) -> Sequence<R>): C
Link copied to clipboard
fun <T> Array<out Array<out T>>.flatten(): List<T>
fun <T> Iterable<Iterable<T>>.flatten(): List<T>
Link copied to clipboard
inline fun <T, R> Array<out T>.fold(initial: R, operation: (acc: R, T) -> R): R
inline fun <R> BooleanArray.fold(initial: R, operation: (acc: R, Boolean) -> R): R
inline fun <R> ByteArray.fold(initial: R, operation: (acc: R, Byte) -> R): R
inline fun <R> CharArray.fold(initial: R, operation: (acc: R, Char) -> R): R
inline fun <R> DoubleArray.fold(initial: R, operation: (acc: R, Double) -> R): R
inline fun <R> FloatArray.fold(initial: R, operation: (acc: R, Float) -> R): R
inline fun <R> IntArray.fold(initial: R, operation: (acc: R, Int) -> R): R
inline fun <R> LongArray.fold(initial: R, operation: (acc: R, Long) -> R): R
inline fun <R> ShortArray.fold(initial: R, operation: (acc: R, Short) -> R): R
inline fun <R> UByteArray.fold(initial: R, operation: (acc: R, UByte) -> R): R
inline fun <R> UIntArray.fold(initial: R, operation: (acc: R, UInt) -> R): R
inline fun <R> ULongArray.fold(initial: R, operation: (acc: R, ULong) -> R): R
inline fun <R> UShortArray.fold(initial: R, operation: (acc: R, UShort) -> R): R
inline fun <T, K, R> Grouping<T, K>.fold(initialValue: R, operation: (accumulator: R, element: T) -> R): Map<K, R>
inline fun <T, K, R> Grouping<T, K>.fold(initialValueSelector: (key: K, element: T) -> R, operation: (key: K, accumulator: R, element: T) -> R): Map<K, R>
inline fun <T, R> Iterable<T>.fold(initial: R, operation: (acc: R, T) -> R): R
Link copied to clipboard
inline fun <T, R> Array<out T>.foldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): R
inline fun <R> BooleanArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Boolean) -> R): R
inline fun <R> ByteArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Byte) -> R): R
inline fun <R> CharArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Char) -> R): R
inline fun <R> DoubleArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Double) -> R): R
inline fun <R> FloatArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Float) -> R): R
inline fun <R> IntArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Int) -> R): R
inline fun <R> LongArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Long) -> R): R
inline fun <R> ShortArray.foldIndexed(initial: R, operation: (index: Int, acc: R, Short) -> R): R
inline fun <R> UByteArray.foldIndexed(initial: R, operation: (index: Int, acc: R, UByte) -> R): R
inline fun <R> UIntArray.foldIndexed(initial: R, operation: (index: Int, acc: R, UInt) -> R): R
inline fun <R> ULongArray.foldIndexed(initial: R, operation: (index: Int, acc: R, ULong) -> R): R
inline fun <R> UShortArray.foldIndexed(initial: R, operation: (index: Int, acc: R, UShort) -> R): R
inline fun <T, R> Iterable<T>.foldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): R
Link copied to clipboard
inline fun <T, R> Array<out T>.foldRight(initial: R, operation: (T, acc: R) -> R): R
inline fun <R> BooleanArray.foldRight(initial: R, operation: (Boolean, acc: R) -> R): R
inline fun <R> ByteArray.foldRight(initial: R, operation: (Byte, acc: R) -> R): R
inline fun <R> CharArray.foldRight(initial: R, operation: (Char, acc: R) -> R): R
inline fun <R> DoubleArray.foldRight(initial: R, operation: (Double, acc: R) -> R): R
inline fun <R> FloatArray.foldRight(initial: R, operation: (Float, acc: R) -> R): R
inline fun <R> IntArray.foldRight(initial: R, operation: (Int, acc: R) -> R): R
inline fun <R> LongArray.foldRight(initial: R, operation: (Long, acc: R) -> R): R
inline fun <R> ShortArray.foldRight(initial: R, operation: (Short, acc: R) -> R): R
inline fun <R> UByteArray.foldRight(initial: R, operation: (UByte, acc: R) -> R): R
inline fun <R> UIntArray.foldRight(initial: R, operation: (UInt, acc: R) -> R): R
inline fun <R> ULongArray.foldRight(initial: R, operation: (ULong, acc: R) -> R): R
inline fun <R> UShortArray.foldRight(initial: R, operation: (UShort, acc: R) -> R): R
inline fun <T, R> List<T>.foldRight(initial: R, operation: (T, acc: R) -> R): R
Link copied to clipboard
inline fun <T, R> Array<out T>.foldRightIndexed(initial: R, operation: (index: Int, T, acc: R) -> R): R
inline fun <R> BooleanArray.foldRightIndexed(initial: R, operation: (index: Int, Boolean, acc: R) -> R): R
inline fun <R> ByteArray.foldRightIndexed(initial: R, operation: (index: Int, Byte, acc: R) -> R): R
inline fun <R> CharArray.foldRightIndexed(initial: R, operation: (index: Int, Char, acc: R) -> R): R
inline fun <R> DoubleArray.foldRightIndexed(initial: R, operation: (index: Int, Double, acc: R) -> R): R
inline fun <R> FloatArray.foldRightIndexed(initial: R, operation: (index: Int, Float, acc: R) -> R): R
inline fun <R> IntArray.foldRightIndexed(initial: R, operation: (index: Int, Int, acc: R) -> R): R
inline fun <R> LongArray.foldRightIndexed(initial: R, operation: (index: Int, Long, acc: R) -> R): R
inline fun <R> ShortArray.foldRightIndexed(initial: R, operation: (index: Int, Short, acc: R) -> R): R
inline fun <R> UByteArray.foldRightIndexed(initial: R, operation: (index: Int, UByte, acc: R) -> R): R
inline fun <R> UIntArray.foldRightIndexed(initial: R, operation: (index: Int, UInt, acc: R) -> R): R
inline fun <R> ULongArray.foldRightIndexed(initial: R, operation: (index: Int, ULong, acc: R) -> R): R
inline fun <R> UShortArray.foldRightIndexed(initial: R, operation: (index: Int, UShort, acc: R) -> R): R
inline fun <T, R> List<T>.foldRightIndexed(initial: R, operation: (index: Int, T, acc: R) -> R): R
Link copied to clipboard
inline fun <T, K, R, M : MutableMap<in K, R>> Grouping<T, K>.foldTo(    destination: M,     initialValue: R,     operation: (accumulator: R, element: T) -> R): M
inline fun <T, K, R, M : MutableMap<in K, R>> Grouping<T, K>.foldTo(    destination: M,     initialValueSelector: (key: K, element: T) -> R,     operation: (key: K, accumulator: R, element: T) -> R): M
Link copied to clipboard
inline fun <T> Array<out T>.forEach(action: (T) -> Unit)
inline fun BooleanArray.forEach(action: (Boolean) -> Unit)
inline fun ByteArray.forEach(action: (Byte) -> Unit)
inline fun CharArray.forEach(action: (Char) -> Unit)
inline fun DoubleArray.forEach(action: (Double) -> Unit)
inline fun FloatArray.forEach(action: (Float) -> Unit)
inline fun IntArray.forEach(action: (Int) -> Unit)
inline fun LongArray.forEach(action: (Long) -> Unit)
inline fun ShortArray.forEach(action: (Short) -> Unit)
inline fun UByteArray.forEach(action: (UByte) -> Unit)
inline fun UIntArray.forEach(action: (UInt) -> Unit)
inline fun ULongArray.forEach(action: (ULong) -> Unit)
inline fun UShortArray.forEach(action: (UShort) -> Unit)
inline fun <T> Iterable<T>.forEach(action: (T) -> Unit)
inline fun <T> Iterator<T>.forEach(operation: (T) -> Unit)
inline fun <K, V> Map<out K, V>.forEach(action: (Map.Entry<K, V>) -> Unit)
Link copied to clipboard
inline fun <T> Array<out T>.forEachIndexed(action: (index: Int, T) -> Unit)
inline fun BooleanArray.forEachIndexed(action: (index: Int, Boolean) -> Unit)
inline fun ByteArray.forEachIndexed(action: (index: Int, Byte) -> Unit)
inline fun CharArray.forEachIndexed(action: (index: Int, Char) -> Unit)
inline fun DoubleArray.forEachIndexed(action: (index: Int, Double) -> Unit)
inline fun FloatArray.forEachIndexed(action: (index: Int, Float) -> Unit)
inline fun IntArray.forEachIndexed(action: (index: Int, Int) -> Unit)
inline fun LongArray.forEachIndexed(action: (index: Int, Long) -> Unit)
inline fun ShortArray.forEachIndexed(action: (index: Int, Short) -> Unit)
inline fun UByteArray.forEachIndexed(action: (index: Int, UByte) -> Unit)
inline fun UIntArray.forEachIndexed(action: (index: Int, UInt) -> Unit)
inline fun ULongArray.forEachIndexed(action: (index: Int, ULong) -> Unit)
inline fun UShortArray.forEachIndexed(action: (index: Int, UShort) -> Unit)
inline fun <T> Iterable<T>.forEachIndexed(action: (index: Int, T) -> Unit)
Link copied to clipboard
inline operator fun <K, V> Map<out K, V>.get(key: K): V?
Link copied to clipboard
inline fun <T> Array<out T>.getOrElse(index: Int, defaultValue: (Int) -> T): T
inline fun BooleanArray.getOrElse(index: Int, defaultValue: (Int) -> Boolean): Boolean
inline fun ByteArray.getOrElse(index: Int, defaultValue: (Int) -> Byte): Byte
inline fun CharArray.getOrElse(index: Int, defaultValue: (Int) -> Char): Char
inline fun DoubleArray.getOrElse(index: Int, defaultValue: (Int) -> Double): Double
inline fun FloatArray.getOrElse(index: Int, defaultValue: (Int) -> Float): Float
inline fun IntArray.getOrElse(index: Int, defaultValue: (Int) -> Int): Int
inline fun LongArray.getOrElse(index: Int, defaultValue: (Int) -> Long): Long
inline fun ShortArray.getOrElse(index: Int, defaultValue: (Int) -> Short): Short
inline fun UByteArray.getOrElse(index: Int, defaultValue: (Int) -> UByte): UByte
inline fun UIntArray.getOrElse(index: Int, defaultValue: (Int) -> UInt): UInt
inline fun ULongArray.getOrElse(index: Int, defaultValue: (Int) -> ULong): ULong
inline fun UShortArray.getOrElse(index: Int, defaultValue: (Int) -> UShort): UShort
inline fun <T> List<T>.getOrElse(index: Int, defaultValue: (Int) -> T): T
inline fun <K, V> Map<K, V>.getOrElse(key: K, defaultValue: () -> V): V
Link copied to clipboard
fun <T> Array<out T>.getOrNull(index: Int): T?
fun BooleanArray.getOrNull(index: Int): Boolean?
fun ByteArray.getOrNull(index: Int): Byte?
fun CharArray.getOrNull(index: Int): Char?
fun DoubleArray.getOrNull(index: Int): Double?
fun FloatArray.getOrNull(index: Int): Float?
fun IntArray.getOrNull(index: Int): Int?
fun LongArray.getOrNull(index: Int): Long?
fun ShortArray.getOrNull(index: Int): Short?
fun UByteArray.getOrNull(index: Int): UByte?
fun UIntArray.getOrNull(index: Int): UInt?
fun ULongArray.getOrNull(index: Int): ULong?
fun UShortArray.getOrNull(index: Int): UShort?
fun <T> List<T>.getOrNull(index: Int): T?
Link copied to clipboard
inline fun <K, V> MutableMap<K, V>.getOrPut(key: K, defaultValue: () -> V): V
Link copied to clipboard
fun <K, V> Map<K, V>.getValue(key: K): V
inline operator fun <V, V1 : V> Map<in String, V>.getValue(thisRef: Any?, property: KProperty<*>): V1
@JvmName(name = "getVar")
inline operator fun <V, V1 : V> MutableMap<in String, out V>.getValue(thisRef: Any?, property: KProperty<*>): V1
Link copied to clipboard
inline fun <T, K> Array<out T>.groupBy(keySelector: (T) -> K): Map<K, List<T>>
inline fun <K> BooleanArray.groupBy(keySelector: (Boolean) -> K): Map<K, List<Boolean>>
inline fun <K> ByteArray.groupBy(keySelector: (Byte) -> K): Map<K, List<Byte>>
inline fun <K> CharArray.groupBy(keySelector: (Char) -> K): Map<K, List<Char>>
inline fun <K> DoubleArray.groupBy(keySelector: (Double) -> K): Map<K, List<Double>>
inline fun <K> FloatArray.groupBy(keySelector: (Float) -> K): Map<K, List<Float>>
inline fun <K> IntArray.groupBy(keySelector: (Int) -> K): Map<K, List<Int>>
inline fun <K> LongArray.groupBy(keySelector: (Long) -> K): Map<K, List<Long>>
inline fun <K> ShortArray.groupBy(keySelector: (Short) -> K): Map<K, List<Short>>
inline fun <K> UByteArray.groupBy(keySelector: (UByte) -> K): Map<K, List<UByte>>
inline fun <K> UIntArray.groupBy(keySelector: (UInt) -> K): Map<K, List<UInt>>
inline fun <K> ULongArray.groupBy(keySelector: (ULong) -> K): Map<K, List<ULong>>
inline fun <K> UShortArray.groupBy(keySelector: (UShort) -> K): Map<K, List<UShort>>
inline fun <T, K> Iterable<T>.groupBy(keySelector: (T) -> K): Map<K, List<T>>
inline fun <T, K, V> Array<out T>.groupBy(keySelector: (T) -> K, valueTransform: (T) -> V): Map<K, List<V>>
inline fun <K, V> BooleanArray.groupBy(keySelector: (Boolean) -> K, valueTransform: (Boolean) -> V): Map<K, List<V>>
inline fun <K, V> ByteArray.groupBy(keySelector: (Byte) -> K, valueTransform: (Byte) -> V): Map<K, List<V>>
inline fun <K, V> CharArray.groupBy(keySelector: (Char) -> K, valueTransform: (Char) -> V): Map<K, List<V>>
inline fun <K, V> DoubleArray.groupBy(keySelector: (Double) -> K, valueTransform: (Double) -> V): Map<K, List<V>>
inline fun <K, V> FloatArray.groupBy(keySelector: (Float) -> K, valueTransform: (Float) -> V): Map<K, List<V>>
inline fun <K, V> IntArray.groupBy(keySelector: (Int) -> K, valueTransform: (Int) -> V): Map<K, List<V>>
inline fun <K, V> LongArray.groupBy(keySelector: (Long) -> K, valueTransform: (Long) -> V): Map<K, List<V>>
inline fun <K, V> ShortArray.groupBy(keySelector: (Short) -> K, valueTransform: (Short) -> V): Map<K, List<V>>
inline fun <K, V> UByteArray.groupBy(keySelector: (UByte) -> K, valueTransform: (UByte) -> V): Map<K, List<V>>
inline fun <K, V> UIntArray.groupBy(keySelector: (UInt) -> K, valueTransform: (UInt) -> V): Map<K, List<V>>
inline fun <K, V> ULongArray.groupBy(keySelector: (ULong) -> K, valueTransform: (ULong) -> V): Map<K, List<V>>
inline fun <K, V> UShortArray.groupBy(keySelector: (UShort) -> K, valueTransform: (UShort) -> V): Map<K, List<V>>
inline fun <T, K, V> Iterable<T>.groupBy(keySelector: (T) -> K, valueTransform: (T) -> V): Map<K, List<V>>
Link copied to clipboard
inline fun <T, K, M : MutableMap<in K, MutableList<T>>> Array<out T>.groupByTo(destination: M, keySelector: (T) -> K): M
inline fun <K, M : MutableMap<in K, MutableList<Boolean>>> BooleanArray.groupByTo(destination: M, keySelector: (Boolean) -> K): M
inline fun <K, M : MutableMap<in K, MutableList<Byte>>> ByteArray.groupByTo(destination: M, keySelector: (Byte) -> K): M
inline fun <K, M : MutableMap<in K, MutableList<Char>>> CharArray.groupByTo(destination: M, keySelector: (Char) -> K): M
inline fun <K, M : MutableMap<in K, MutableList<Double>>> DoubleArray.groupByTo(destination: M, keySelector: (Double) -> K): M
inline fun <K, M : MutableMap<in K, MutableList<Float>>> FloatArray.groupByTo(destination: M, keySelector: (Float) -> K): M
inline fun <K, M : MutableMap<in K, MutableList<Int>>> IntArray.groupByTo(destination: M, keySelector: (Int) -> K): M
inline fun <K, M : MutableMap<in K, MutableList<Long>>> LongArray.groupByTo(destination: M, keySelector: (Long) -> K): M
inline fun <K, M : MutableMap<in K, MutableList<Short>>> ShortArray.groupByTo(destination: M, keySelector: (Short) -> K): M
inline fun <K, M : MutableMap<in K, MutableList<UByte>>> UByteArray.groupByTo(destination: M, keySelector: (UByte) -> K): M
inline fun <K, M : MutableMap<in K, MutableList<UInt>>> UIntArray.groupByTo(destination: M, keySelector: (UInt) -> K): M
inline fun <K, M : MutableMap<in K, MutableList<ULong>>> ULongArray.groupByTo(destination: M, keySelector: (ULong) -> K): M
inline fun <K, M : MutableMap<in K, MutableList<UShort>>> UShortArray.groupByTo(destination: M, keySelector: (UShort) -> K): M
inline fun <T, K, M : MutableMap<in K, MutableList<T>>> Iterable<T>.groupByTo(destination: M, keySelector: (T) -> K): M
inline fun <T, K, V, M : MutableMap<in K, MutableList<V>>> Array<out T>.groupByTo(    destination: M,     keySelector: (T) -> K,     valueTransform: (T) -> V): M
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> BooleanArray.groupByTo(    destination: M,     keySelector: (Boolean) -> K,     valueTransform: (Boolean) -> V): M
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> ByteArray.groupByTo(    destination: M,     keySelector: (Byte) -> K,     valueTransform: (Byte) -> V): M
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> CharArray.groupByTo(    destination: M,     keySelector: (Char) -> K,     valueTransform: (Char) -> V): M
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> DoubleArray.groupByTo(    destination: M,     keySelector: (Double) -> K,     valueTransform: (Double) -> V): M
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> FloatArray.groupByTo(    destination: M,     keySelector: (Float) -> K,     valueTransform: (Float) -> V): M
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> IntArray.groupByTo(    destination: M,     keySelector: (Int) -> K,     valueTransform: (Int) -> V): M
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> LongArray.groupByTo(    destination: M,     keySelector: (Long) -> K,     valueTransform: (Long) -> V): M
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> ShortArray.groupByTo(    destination: M,     keySelector: (Short) -> K,     valueTransform: (Short) -> V): M
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> UByteArray.groupByTo(    destination: M,     keySelector: (UByte) -> K,     valueTransform: (UByte) -> V): M
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> UIntArray.groupByTo(    destination: M,     keySelector: (UInt) -> K,     valueTransform: (UInt) -> V): M
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> ULongArray.groupByTo(    destination: M,     keySelector: (ULong) -> K,     valueTransform: (ULong) -> V): M
inline fun <K, V, M : MutableMap<in K, MutableList<V>>> UShortArray.groupByTo(    destination: M,     keySelector: (UShort) -> K,     valueTransform: (UShort) -> V): M
inline fun <T, K, V, M : MutableMap<in K, MutableList<V>>> Iterable<T>.groupByTo(    destination: M,     keySelector: (T) -> K,     valueTransform: (T) -> V): M
Link copied to clipboard
inline fun <T, K> Array<out T>.groupingBy(crossinline keySelector: (T) -> K): Grouping<T, K>
inline fun <T, K> Iterable<T>.groupingBy(crossinline keySelector: (T) -> K): Grouping<T, K>
Link copied to clipboard
inline fun <K, V> hashMapOf(): HashMap<K, V>
fun <K, V> hashMapOf(vararg pairs: Pair<K, V>): HashMap<K, V>
Link copied to clipboard
inline fun <T> hashSetOf(): HashSet<T>
fun <T> hashSetOf(vararg elements: T): HashSet<T>
Link copied to clipboard
inline fun <C : Array<*>, R, R> C.ifEmpty(defaultValue: () -> R): R
inline fun <C : Collection<*>, R, R> C.ifEmpty(defaultValue: () -> R): R
inline fun <M : Map<*, *>, R, R> M.ifEmpty(defaultValue: () -> R): R
Link copied to clipboard
fun <T> Array<out T>.indexOf(element: T): Int
fun BooleanArray.indexOf(element: Boolean): Int
fun ByteArray.indexOf(element: Byte): Int
fun CharArray.indexOf(element: Char): Int
@DeprecatedSinceKotlin(errorSince = "1.6", hiddenSince = "1.7", warningSince = "1.4")
fun DoubleArray.indexOf(element: Double): Int
@DeprecatedSinceKotlin(errorSince = "1.6", hiddenSince = "1.7", warningSince = "1.4")
fun FloatArray.indexOf(element: Float): Int
fun IntArray.indexOf(element: Int): Int
fun LongArray.indexOf(element: Long): Int
fun ShortArray.indexOf(element: Short): Int
inline fun UByteArray.indexOf(element: UByte): Int
inline fun UIntArray.indexOf(element: UInt): Int
inline fun ULongArray.indexOf(element: ULong): Int
inline fun UShortArray.indexOf(element: UShort): Int
fun <T> Iterable<T>.indexOf(element: T): Int
fun <T> List<T>.indexOf(element: T): Int
Link copied to clipboard
inline fun <T> Array<out T>.indexOfFirst(predicate: (T) -> Boolean): Int
inline fun BooleanArray.indexOfFirst(predicate: (Boolean) -> Boolean): Int
inline fun ByteArray.indexOfFirst(predicate: (Byte) -> Boolean): Int
inline fun CharArray.indexOfFirst(predicate: (Char) -> Boolean): Int
inline fun DoubleArray.indexOfFirst(predicate: (Double) -> Boolean): Int
inline fun FloatArray.indexOfFirst(predicate: (Float) -> Boolean): Int
inline fun IntArray.indexOfFirst(predicate: (Int) -> Boolean): Int
inline fun LongArray.indexOfFirst(predicate: (Long) -> Boolean): Int
inline fun ShortArray.indexOfFirst(predicate: (Short) -> Boolean): Int
inline fun UByteArray.indexOfFirst(predicate: (UByte) -> Boolean): Int
inline fun UIntArray.indexOfFirst(predicate: (UInt) -> Boolean): Int
inline fun ULongArray.indexOfFirst(predicate: (ULong) -> Boolean): Int
inline fun UShortArray.indexOfFirst(predicate: (UShort) -> Boolean): Int
inline fun <T> Iterable<T>.indexOfFirst(predicate: (T) -> Boolean): Int
inline fun <T> List<T>.indexOfFirst(predicate: (T) -> Boolean): Int
Link copied to clipboard
inline fun <T> Array<out T>.indexOfLast(predicate: (T) -> Boolean): Int
inline fun BooleanArray.indexOfLast(predicate: (Boolean) -> Boolean): Int
inline fun ByteArray.indexOfLast(predicate: (Byte) -> Boolean): Int
inline fun CharArray.indexOfLast(predicate: (Char) -> Boolean): Int
inline fun DoubleArray.indexOfLast(predicate: (Double) -> Boolean): Int
inline fun FloatArray.indexOfLast(predicate: (Float) -> Boolean): Int
inline fun IntArray.indexOfLast(predicate: (Int) -> Boolean): Int
inline fun LongArray.indexOfLast(predicate: (Long) -> Boolean): Int
inline fun ShortArray.indexOfLast(predicate: (Short) -> Boolean): Int
inline fun UByteArray.indexOfLast(predicate: (UByte) -> Boolean): Int
inline fun UIntArray.indexOfLast(predicate: (UInt) -> Boolean): Int
inline fun ULongArray.indexOfLast(predicate: (ULong) -> Boolean): Int
inline fun UShortArray.indexOfLast(predicate: (UShort) -> Boolean): Int
inline fun <T> Iterable<T>.indexOfLast(predicate: (T) -> Boolean): Int
inline fun <T> List<T>.indexOfLast(predicate: (T) -> Boolean): Int
Link copied to clipboard
infix fun <T> Array<out T>.intersect(other: Iterable<T>): Set<T>
infix fun BooleanArray.intersect(other: Iterable<Boolean>): Set<Boolean>
infix fun ByteArray.intersect(other: Iterable<Byte>): Set<Byte>
infix fun CharArray.intersect(other: Iterable<Char>): Set<Char>
infix fun DoubleArray.intersect(other: Iterable<Double>): Set<Double>
infix fun FloatArray.intersect(other: Iterable<Float>): Set<Float>
infix fun IntArray.intersect(other: Iterable<Int>): Set<Int>
infix fun LongArray.intersect(other: Iterable<Long>): Set<Long>
infix fun ShortArray.intersect(other: Iterable<Short>): Set<Short>
infix fun <T> Iterable<T>.intersect(other: Iterable<T>): Set<T>
Link copied to clipboard
inline fun <T> Array<out T>.isEmpty(): Boolean
inline fun BooleanArray.isEmpty(): Boolean
inline fun ByteArray.isEmpty(): Boolean
inline fun CharArray.isEmpty(): Boolean
inline fun DoubleArray.isEmpty(): Boolean
inline fun FloatArray.isEmpty(): Boolean
inline fun IntArray.isEmpty(): Boolean
inline fun LongArray.isEmpty(): Boolean
inline fun ShortArray.isEmpty(): Boolean
Link copied to clipboard
inline fun <T> Array<out T>.isNotEmpty(): Boolean
inline fun BooleanArray.isNotEmpty(): Boolean
inline fun ByteArray.isNotEmpty(): Boolean
inline fun CharArray.isNotEmpty(): Boolean
inline fun DoubleArray.isNotEmpty(): Boolean
inline fun FloatArray.isNotEmpty(): Boolean
inline fun IntArray.isNotEmpty(): Boolean
inline fun LongArray.isNotEmpty(): Boolean
inline fun ShortArray.isNotEmpty(): Boolean
inline fun <T> Collection<T>.isNotEmpty(): Boolean
inline fun <K, V> Map<out K, V>.isNotEmpty(): Boolean
Link copied to clipboard
inline fun Array<*>?.isNullOrEmpty(): Boolean
inline fun <T> Collection<T>?.isNullOrEmpty(): Boolean
inline fun <K, V> Map<out K, V>?.isNullOrEmpty(): Boolean
Link copied to clipboard
inline fun <T> Iterable(crossinline iterator: () -> Iterator<T>): Iterable<T>
Link copied to clipboard
inline operator fun <T> Iterator<T>.iterator(): Iterator<T>
inline operator fun <K, V> Map<out K, V>.iterator(): Iterator<Map.Entry<K, V>>
@JvmName(name = "mutableIterator")
inline operator fun <K, V> MutableMap<K, V>.iterator(): MutableIterator<MutableMap.MutableEntry<K, V>>
Link copied to clipboard
fun <T, A : Appendable> Array<out T>.joinTo(buffer: A, separator: CharSequence)
fun <A : Appendable> BooleanArray.joinTo(buffer: A, separator: CharSequence)
fun <A : Appendable> ByteArray.joinTo(buffer: A, separator: CharSequence)
fun <A : Appendable> CharArray.joinTo(buffer: A, separator: CharSequence)
fun <A : Appendable> DoubleArray.joinTo(buffer: A, separator: CharSequence)
fun <A : Appendable> FloatArray.joinTo(buffer: A, separator: CharSequence)
fun <A : Appendable> IntArray.joinTo(buffer: A, separator: CharSequence)
fun <A : Appendable> LongArray.joinTo(buffer: A, separator: CharSequence)
fun <A : Appendable> ShortArray.joinTo(buffer: A, separator: CharSequence)
fun <T, A : Appendable> Iterable<T>.joinTo(buffer: A, separator: CharSequence)
Link copied to clipboard
fun <T> Array<out T>.joinToString(separator: CharSequence)
fun BooleanArray.joinToString(separator: CharSequence)
fun ByteArray.joinToString(separator: CharSequence)
fun CharArray.joinToString(separator: CharSequence)
fun DoubleArray.joinToString(separator: CharSequence)
fun FloatArray.joinToString(separator: CharSequence)
fun IntArray.joinToString(separator: CharSequence)
fun LongArray.joinToString(separator: CharSequence)
fun ShortArray.joinToString(separator: CharSequence)
fun <T> Iterable<T>.joinToString(separator: CharSequence)
Link copied to clipboard
fun <T> Array<out T>.last(): T
fun BooleanArray.last(): Boolean
fun ByteArray.last(): Byte
fun CharArray.last(): Char
fun DoubleArray.last(): Double
fun FloatArray.last(): Float
fun IntArray.last(): Int
fun LongArray.last(): Long
fun ShortArray.last(): Short
inline fun UByteArray.last(): UByte
inline fun UIntArray.last(): UInt
inline fun ULongArray.last(): ULong
inline fun UShortArray.last(): UShort
fun <T> Iterable<T>.last(): T
fun <T> List<T>.last(): T
inline fun <T> Array<out T>.last(predicate: (T) -> Boolean): T
inline fun BooleanArray.last(predicate: (Boolean) -> Boolean): Boolean
inline fun ByteArray.last(predicate: (Byte) -> Boolean): Byte
inline fun CharArray.last(predicate: (Char) -> Boolean): Char
inline fun DoubleArray.last(predicate: (Double) -> Boolean): Double
inline fun FloatArray.last(predicate: (Float) -> Boolean): Float
inline fun IntArray.last(predicate: (Int) -> Boolean): Int
inline fun LongArray.last(predicate: (Long) -> Boolean): Long
inline fun ShortArray.last(predicate: (Short) -> Boolean): Short
inline fun UByteArray.last(predicate: (UByte) -> Boolean): UByte
inline fun UIntArray.last(predicate: (UInt) -> Boolean): UInt
inline fun ULongArray.last(predicate: (ULong) -> Boolean): ULong
inline fun UShortArray.last(predicate: (UShort) -> Boolean): UShort
inline fun <T> Iterable<T>.last(predicate: (T) -> Boolean): T
inline fun <T> List<T>.last(predicate: (T) -> Boolean): T
Link copied to clipboard
fun <T> Array<out T>.lastIndexOf(element: T): Int
fun BooleanArray.lastIndexOf(element: Boolean): Int
fun ByteArray.lastIndexOf(element: Byte): Int
fun CharArray.lastIndexOf(element: Char): Int
@DeprecatedSinceKotlin(errorSince = "1.6", hiddenSince = "1.7", warningSince = "1.4")
fun DoubleArray.lastIndexOf(element: Double): Int
@DeprecatedSinceKotlin(errorSince = "1.6", hiddenSince = "1.7", warningSince = "1.4")
fun FloatArray.lastIndexOf(element: Float): Int
fun IntArray.lastIndexOf(element: Int): Int
fun LongArray.lastIndexOf(element: Long): Int
fun ShortArray.lastIndexOf(element: Short): Int
inline fun UByteArray.lastIndexOf(element: UByte): Int
inline fun UIntArray.lastIndexOf(element: UInt): Int
inline fun ULongArray.lastIndexOf(element: ULong): Int
inline fun UShortArray.lastIndexOf(element: UShort): Int
fun <T> Iterable<T>.lastIndexOf(element: T): Int
fun <T> List<T>.lastIndexOf(element: T): Int
Link copied to clipboard
fun <T> Array<out T>.lastOrNull(): T?
fun BooleanArray.lastOrNull(): Boolean?
fun ByteArray.lastOrNull(): Byte?
fun CharArray.lastOrNull(): Char?
fun DoubleArray.lastOrNull(): Double?
fun FloatArray.lastOrNull(): Float?
fun IntArray.lastOrNull(): Int?
fun LongArray.lastOrNull(): Long?
fun ShortArray.lastOrNull(): Short?
fun UByteArray.lastOrNull(): UByte?
fun UIntArray.lastOrNull(): UInt?
fun ULongArray.lastOrNull(): ULong?
fun UShortArray.lastOrNull(): UShort?
fun <T> Iterable<T>.lastOrNull(): T?
fun <T> List<T>.lastOrNull(): T?
inline fun <T> Array<out T>.lastOrNull(predicate: (T) -> Boolean): T?
inline fun BooleanArray.lastOrNull(predicate: (Boolean) -> Boolean): Boolean?
inline fun ByteArray.lastOrNull(predicate: (Byte) -> Boolean): Byte?
inline fun CharArray.lastOrNull(predicate: (Char) -> Boolean): Char?
inline fun DoubleArray.lastOrNull(predicate: (Double) -> Boolean): Double?
inline fun FloatArray.lastOrNull(predicate: (Float) -> Boolean): Float?
inline fun IntArray.lastOrNull(predicate: (Int) -> Boolean): Int?
inline fun LongArray.lastOrNull(predicate: (Long) -> Boolean): Long?
inline fun ShortArray.lastOrNull(predicate: (Short) -> Boolean): Short?
inline fun UByteArray.lastOrNull(predicate: (UByte) -> Boolean): UByte?
inline fun UIntArray.lastOrNull(predicate: (UInt) -> Boolean): UInt?
inline fun ULongArray.lastOrNull(predicate: (ULong) -> Boolean): ULong?
inline fun UShortArray.lastOrNull(predicate: (UShort) -> Boolean): UShort?
inline fun <T> Iterable<T>.lastOrNull(predicate: (T) -> Boolean): T?
inline fun <T> List<T>.lastOrNull(predicate: (T) -> Boolean): T?
Link copied to clipboard
inline fun <K, V> linkedMapOf(): LinkedHashMap<K, V>
fun <K, V> linkedMapOf(vararg pairs: Pair<K, V>): LinkedHashMap<K, V>
Link copied to clipboard
inline fun <T> linkedSetOf(): LinkedHashSet<T>
fun <T> linkedSetOf(vararg elements: T): LinkedHashSet<T>
Link copied to clipboard
fun <V> linkedStringMapOf(vararg pairs: Pair<String, V>): LinkedHashMap<String, V>
Link copied to clipboard
fun linkedStringSetOf(vararg elements: String): LinkedHashSet<String>
Link copied to clipboard
inline fun <T> List(size: Int, init: (index: Int) -> T): List<T>
Link copied to clipboard
inline fun <T> listOf(): List<T>
fun <T> listOf(element: T): List<T>
fun <T> listOf(vararg elements: T): List<T>
Link copied to clipboard
fun <T : Any> listOfNotNull(element: T?): List<T>
fun <T : Any> listOfNotNull(vararg elements: T?): List<T>
Link copied to clipboard
inline fun <T, R> Array<out T>.map(transform: (T) -> R): List<R>
inline fun <R> BooleanArray.map(transform: (Boolean) -> R): List<R>
inline fun <R> ByteArray.map(transform: (Byte) -> R): List<R>
inline fun <R> CharArray.map(transform: (Char) -> R): List<R>
inline fun <R> DoubleArray.map(transform: (Double) -> R): List<R>
inline fun <R> FloatArray.map(transform: (Float) -> R): List<R>
inline fun <R> IntArray.map(transform: (Int) -> R): List<R>
inline fun <R> LongArray.map(transform: (Long) -> R): List<R>
inline fun <R> ShortArray.map(transform: (Short) -> R): List<R>
inline fun <R> UByteArray.map(transform: (UByte) -> R): List<R>
inline fun <R> UIntArray.map(transform: (UInt) -> R): List<R>
inline fun <R> ULongArray.map(transform: (ULong) -> R): List<R>
inline fun <R> UShortArray.map(transform: (UShort) -> R): List<R>
inline fun <T, R> Iterable<T>.map(transform: (T) -> R): List<R>
inline fun <K, V, R> Map<out K, V>.map(transform: (Map.Entry<K, V>) -> R): List<R>
Link copied to clipboard
inline fun <T, R> Array<out T>.mapIndexed(transform: (index: Int, T) -> R): List<R>
inline fun <R> BooleanArray.mapIndexed(transform: (index: Int, Boolean) -> R): List<R>
inline fun <R> ByteArray.mapIndexed(transform: (index: Int, Byte) -> R): List<R>
inline fun <R> CharArray.mapIndexed(transform: (index: Int, Char) -> R): List<R>
inline fun <R> DoubleArray.mapIndexed(transform: (index: Int, Double) -> R): List<R>
inline fun <R> FloatArray.mapIndexed(transform: (index: Int, Float) -> R): List<R>
inline fun <R> IntArray.mapIndexed(transform: (index: Int, Int) -> R): List<R>
inline fun <R> LongArray.mapIndexed(transform: (index: Int, Long) -> R): List<R>
inline fun <R> ShortArray.mapIndexed(transform: (index: Int, Short) -> R): List<R>
inline fun <R> UByteArray.mapIndexed(transform: (index: Int, UByte) -> R): List<R>
inline fun <R> UIntArray.mapIndexed(transform: (index: Int, UInt) -> R): List<R>
inline fun <R> ULongArray.mapIndexed(transform: (index: Int, ULong) -> R): List<R>
inline fun <R> UShortArray.mapIndexed(transform: (index: Int, UShort) -> R): List<R>
inline fun <T, R> Iterable<T>.mapIndexed(transform: (index: Int, T) -> R): List<R>
Link copied to clipboard
inline fun <T, R : Any> Array<out T>.mapIndexedNotNull(transform: (index: Int, T) -> R?): List<R>
inline fun <T, R : Any> Iterable<T>.mapIndexedNotNull(transform: (index: Int, T) -> R?): List<R>
Link copied to clipboard
inline fun <T, R : Any, C : MutableCollection<in R>> Array<out T>.mapIndexedNotNullTo(destination: C, transform: (index: Int, T) -> R?): C
inline fun <T, R : Any, C : MutableCollection<in R>> Iterable<T>.mapIndexedNotNullTo(destination: C, transform: (index: Int, T) -> R?): C
Link copied to clipboard
inline fun <T, R, C : MutableCollection<in R>> Array<out T>.mapIndexedTo(destination: C, transform: (index: Int, T) -> R): C
inline fun <R, C : MutableCollection<in R>> BooleanArray.mapIndexedTo(destination: C, transform: (index: Int, Boolean) -> R): C
inline fun <R, C : MutableCollection<in R>> ByteArray.mapIndexedTo(destination: C, transform: (index: Int, Byte) -> R): C
inline fun <R, C : MutableCollection<in R>> CharArray.mapIndexedTo(destination: C, transform: (index: Int, Char) -> R): C
inline fun <R, C : MutableCollection<in R>> DoubleArray.mapIndexedTo(destination: C, transform: (index: Int, Double) -> R): C
inline fun <R, C : MutableCollection<in R>> FloatArray.mapIndexedTo(destination: C, transform: (index: Int, Float) -> R): C
inline fun <R, C : MutableCollection<in R>> IntArray.mapIndexedTo(destination: C, transform: (index: Int, Int) -> R): C
inline fun <R, C : MutableCollection<in R>> LongArray.mapIndexedTo(destination: C, transform: (index: Int, Long) -> R): C
inline fun <R, C : MutableCollection<in R>> ShortArray.mapIndexedTo(destination: C, transform: (index: Int, Short) -> R): C
inline fun <R, C : MutableCollection<in R>> UByteArray.mapIndexedTo(destination: C, transform: (index: Int, UByte) -> R): C
inline fun <R, C : MutableCollection<in R>> UIntArray.mapIndexedTo(destination: C, transform: (index: Int, UInt) -> R): C
inline fun <R, C : MutableCollection<in R>> ULongArray.mapIndexedTo(destination: C, transform: (index: Int, ULong) -> R): C
inline fun <R, C : MutableCollection<in R>> UShortArray.mapIndexedTo(destination: C, transform: (index: Int, UShort) -> R): C
inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapIndexedTo(destination: C, transform: (index: Int, T) -> R): C
Link copied to clipboard
inline fun <K, V, R> Map<out K, V>.mapKeys(transform: (Map.Entry<K, V>) -> R): Map<R, V>
Link copied to clipboard
inline fun <K, V, R, M : MutableMap<in R, in V>> Map<out K, V>.mapKeysTo(destination: M, transform: (Map.Entry<K, V>) -> R): M
Link copied to clipboard
inline fun <T, R : Any> Array<out T>.mapNotNull(transform: (T) -> R?): List<R>
inline fun <T, R : Any> Iterable<T>.mapNotNull(transform: (T) -> R?): List<R>
inline fun <K, V, R : Any> Map<out K, V>.mapNotNull(transform: (Map.Entry<K, V>) -> R?): List<R>
Link copied to clipboard
inline fun <T, R : Any, C : MutableCollection<in R>> Array<out T>.mapNotNullTo(destination: C, transform: (T) -> R?): C
inline fun <T, R : Any, C : MutableCollection<in R>> Iterable<T>.mapNotNullTo(destination: C, transform: (T) -> R?): C
inline fun <K, V, R : Any, C : MutableCollection<in R>> Map<out K, V>.mapNotNullTo(destination: C, transform: (Map.Entry<K, V>) -> R?): C
Link copied to clipboard
inline fun <K, V> mapOf(): Map<K, V>
fun <K, V> mapOf(vararg pairs: Pair<K, V>): Map<K, V>
fun <K, V> mapOf(pair: Pair<K, V>): Map<K, V>
Link copied to clipboard
inline fun <T, R, C : MutableCollection<in R>> Array<out T>.mapTo(destination: C, transform: (T) -> R): C
inline fun <R, C : MutableCollection<in R>> BooleanArray.mapTo(destination: C, transform: (Boolean) -> R): C
inline fun <R, C : MutableCollection<in R>> ByteArray.mapTo(destination: C, transform: (Byte) -> R): C
inline fun <R, C : MutableCollection<in R>> CharArray.mapTo(destination: C, transform: (Char) -> R): C
inline fun <R, C : MutableCollection<in R>> DoubleArray.mapTo(destination: C, transform: (Double) -> R): C
inline fun <R, C : MutableCollection<in R>> FloatArray.mapTo(destination: C, transform: (Float) -> R): C
inline fun <R, C : MutableCollection<in R>> IntArray.mapTo(destination: C, transform: (Int) -> R): C
inline fun <R, C : MutableCollection<in R>> LongArray.mapTo(destination: C, transform: (Long) -> R): C
inline fun <R, C : MutableCollection<in R>> ShortArray.mapTo(destination: C, transform: (Short) -> R): C
inline fun <R, C : MutableCollection<in R>> UByteArray.mapTo(destination: C, transform: (UByte) -> R): C
inline fun <R, C : MutableCollection<in R>> UIntArray.mapTo(destination: C, transform: (UInt) -> R): C
inline fun <R, C : MutableCollection<in R>> ULongArray.mapTo(destination: C, transform: (ULong) -> R): C
inline fun <R, C : MutableCollection<in R>> UShortArray.mapTo(destination: C, transform: (UShort) -> R): C
inline fun <T, R, C : MutableCollection<in R>> Iterable<T>.mapTo(destination: C, transform: (T) -> R): C
inline fun <K, V, R, C : MutableCollection<in R>> Map<out K, V>.mapTo(destination: C, transform: (Map.Entry<K, V>) -> R): C
Link copied to clipboard
inline fun <K, V, R> Map<out K, V>.mapValues(transform: (Map.Entry<K, V>) -> R): Map<K, R>
Link copied to clipboard
inline fun <K, V, R, M : MutableMap<in K, in R>> Map<out K, V>.mapValuesTo(destination: M, transform: (Map.Entry<K, V>) -> R): M
Link copied to clipboard
@JvmName(name = "maxOrThrow")
fun <T : Comparable<T>> Array<out T>.max(): T
@JvmName(name = "maxOrThrow")
fun DoubleArray.max(): Double
@JvmName(name = "maxOrThrow")
fun FloatArray.max(): Float
@JvmName(name = "maxOrThrow")
fun ByteArray.max(): Byte
@JvmName(name = "maxOrThrow")
fun CharArray.max(): Char
@JvmName(name = "maxOrThrow")
fun DoubleArray.max(): Double
@JvmName(name = "maxOrThrow")
fun FloatArray.max(): Float
@JvmName(name = "maxOrThrow")
fun IntArray.max(): Int
@JvmName(name = "maxOrThrow")
fun LongArray.max(): Long
@JvmName(name = "maxOrThrow")
fun ShortArray.max(): Short
@JvmName(name = "maxOrThrow-U")
fun UByteArray.max(): UByte
@JvmName(name = "maxOrThrow-U")
fun UIntArray.max(): UInt
@JvmName(name = "maxOrThrow-U")
fun ULongArray.max(): ULong
@JvmName(name = "maxOrThrow-U")
fun UShortArray.max(): UShort
@JvmName(name = "maxOrThrow")
fun <T : Comparable<T>> Iterable<T>.max(): T
@JvmName(name = "maxOrThrow")
fun Iterable<Double>.max(): Double
@JvmName(name = "maxOrThrow")
fun Iterable<Float>.max(): Float
Link copied to clipboard
@JvmName(name = "maxByOrThrow")
inline fun <T, R : Comparable<R>> Array<out T>.maxBy(selector: (T) -> R): T
@JvmName(name = "maxByOrThrow")
inline fun <R : Comparable<R>> BooleanArray.maxBy(selector: (Boolean) -> R): Boolean
@JvmName(name = "maxByOrThrow")
inline fun <R : Comparable<R>> ByteArray.maxBy(selector: (Byte) -> R): Byte
@JvmName(name = "maxByOrThrow")
inline fun <R : Comparable<R>> CharArray.maxBy(selector: (Char) -> R): Char
@JvmName(name = "maxByOrThrow")
inline fun <R : Comparable<R>> DoubleArray.maxBy(selector: (Double) -> R): Double
@JvmName(name = "maxByOrThrow")
inline fun <R : Comparable<R>> FloatArray.maxBy(selector: (Float) -> R): Float
@JvmName(name = "maxByOrThrow")
inline fun <R : Comparable<R>> IntArray.maxBy(selector: (Int) -> R): Int
@JvmName(name = "maxByOrThrow")
inline fun <R : Comparable<R>> LongArray.maxBy(selector: (Long) -> R): Long
@JvmName(name = "maxByOrThrow")
inline fun <R : Comparable<R>> ShortArray.maxBy(selector: (Short) -> R): Short
@JvmName(name = "maxByOrThrow-U")
inline fun <R : Comparable<R>> UByteArray.maxBy(selector: (UByte) -> R): UByte
@JvmName(name = "maxByOrThrow-U")
inline fun <R : Comparable<R>> UIntArray.maxBy(selector: (UInt) -> R): UInt
@JvmName(name = "maxByOrThrow-U")
inline fun <R : Comparable<R>> ULongArray.maxBy(selector: (ULong) -> R): ULong
@JvmName(name = "maxByOrThrow-U")
inline fun <R : Comparable<R>> UShortArray.maxBy(selector: (UShort) -> R): UShort
@JvmName(name = "maxByOrThrow")
inline fun <T, R : Comparable<R>> Iterable<T>.maxBy(selector: (T) -> R): T
@JvmName(name = "maxByOrThrow")
inline fun <K, V, R : Comparable<R>> Map<out K, V>.maxBy(selector: (Map.Entry<K, V>) -> R): Map.Entry<K, V>
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.maxByOrNull(selector: (T) -> R): T?
inline fun <R : Comparable<R>> BooleanArray.maxByOrNull(selector: (Boolean) -> R): Boolean?
inline fun <R : Comparable<R>> ByteArray.maxByOrNull(selector: (Byte) -> R): Byte?
inline fun <R : Comparable<R>> CharArray.maxByOrNull(selector: (Char) -> R): Char?
inline fun <R : Comparable<R>> DoubleArray.maxByOrNull(selector: (Double) -> R): Double?
inline fun <R : Comparable<R>> FloatArray.maxByOrNull(selector: (Float) -> R): Float?
inline fun <R : Comparable<R>> IntArray.maxByOrNull(selector: (Int) -> R): Int?
inline fun <R : Comparable<R>> LongArray.maxByOrNull(selector: (Long) -> R): Long?
inline fun <R : Comparable<R>> ShortArray.maxByOrNull(selector: (Short) -> R): Short?
inline fun <R : Comparable<R>> UByteArray.maxByOrNull(selector: (UByte) -> R): UByte?
inline fun <R : Comparable<R>> UIntArray.maxByOrNull(selector: (UInt) -> R): UInt?
inline fun <R : Comparable<R>> ULongArray.maxByOrNull(selector: (ULong) -> R): ULong?
inline fun <R : Comparable<R>> UShortArray.maxByOrNull(selector: (UShort) -> R): UShort?
inline fun <T, R : Comparable<R>> Iterable<T>.maxByOrNull(selector: (T) -> R): T?
inline fun <K, V, R : Comparable<R>> Map<out K, V>.maxByOrNull(selector: (Map.Entry<K, V>) -> R): Map.Entry<K, V>?
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.maxOf(selector: (T) -> R): R
inline fun <T> Array<out T>.maxOf(selector: (T) -> Double): Double
inline fun <T> Array<out T>.maxOf(selector: (T) -> Float): Float
inline fun <R : Comparable<R>> BooleanArray.maxOf(selector: (Boolean) -> R): R
inline fun BooleanArray.maxOf(selector: (Boolean) -> Double): Double
inline fun BooleanArray.maxOf(selector: (Boolean) -> Float): Float
inline fun <R : Comparable<R>> ByteArray.maxOf(selector: (Byte) -> R): R
inline fun ByteArray.maxOf(selector: (Byte) -> Double): Double
inline fun ByteArray.maxOf(selector: (Byte) -> Float): Float
inline fun <R : Comparable<R>> CharArray.maxOf(selector: (Char) -> R): R
inline fun CharArray.maxOf(selector: (Char) -> Double): Double
inline fun CharArray.maxOf(selector: (Char) -> Float): Float
inline fun <R : Comparable<R>> DoubleArray.maxOf(selector: (Double) -> R): R
inline fun DoubleArray.maxOf(selector: (Double) -> Double): Double
inline fun DoubleArray.maxOf(selector: (Double) -> Float): Float
inline fun <R : Comparable<R>> FloatArray.maxOf(selector: (Float) -> R): R
inline fun FloatArray.maxOf(selector: (Float) -> Double): Double
inline fun FloatArray.maxOf(selector: (Float) -> Float): Float
inline fun <R : Comparable<R>> IntArray.maxOf(selector: (Int) -> R): R
inline fun IntArray.maxOf(selector: (Int) -> Double): Double
inline fun IntArray.maxOf(selector: (Int) -> Float): Float
inline fun <R : Comparable<R>> LongArray.maxOf(selector: (Long) -> R): R
inline fun LongArray.maxOf(selector: (Long) -> Double): Double
inline fun LongArray.maxOf(selector: (Long) -> Float): Float
inline fun <R : Comparable<R>> ShortArray.maxOf(selector: (Short) -> R): R
inline fun ShortArray.maxOf(selector: (Short) -> Double): Double
inline fun ShortArray.maxOf(selector: (Short) -> Float): Float
inline fun <R : Comparable<R>> UByteArray.maxOf(selector: (UByte) -> R): R
inline fun UByteArray.maxOf(selector: (UByte) -> Double): Double
inline fun UByteArray.maxOf(selector: (UByte) -> Float): Float
inline fun <R : Comparable<R>> UIntArray.maxOf(selector: (UInt) -> R): R
inline fun UIntArray.maxOf(selector: (UInt) -> Double): Double
inline fun UIntArray.maxOf(selector: (UInt) -> Float): Float
inline fun <R : Comparable<R>> ULongArray.maxOf(selector: (ULong) -> R): R
inline fun ULongArray.maxOf(selector: (ULong) -> Double): Double
inline fun ULongArray.maxOf(selector: (ULong) -> Float): Float
inline fun <R : Comparable<R>> UShortArray.maxOf(selector: (UShort) -> R): R
inline fun UShortArray.maxOf(selector: (UShort) -> Double): Double
inline fun UShortArray.maxOf(selector: (UShort) -> Float): Float
inline fun <T, R : Comparable<R>> Iterable<T>.maxOf(selector: (T) -> R): R
inline fun <T> Iterable<T>.maxOf(selector: (T) -> Double): Double
inline fun <T> Iterable<T>.maxOf(selector: (T) -> Float): Float
inline fun <K, V, R : Comparable<R>> Map<out K, V>.maxOf(selector: (Map.Entry<K, V>) -> R): R
inline fun <K, V> Map<out K, V>.maxOf(selector: (Map.Entry<K, V>) -> Double): Double
inline fun <K, V> Map<out K, V>.maxOf(selector: (Map.Entry<K, V>) -> Float): Float
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.maxOfOrNull(selector: (T) -> R): R?
inline fun <T> Array<out T>.maxOfOrNull(selector: (T) -> Double): Double?
inline fun <T> Array<out T>.maxOfOrNull(selector: (T) -> Float): Float?
inline fun <R : Comparable<R>> BooleanArray.maxOfOrNull(selector: (Boolean) -> R): R?
inline fun BooleanArray.maxOfOrNull(selector: (Boolean) -> Double): Double?
inline fun BooleanArray.maxOfOrNull(selector: (Boolean) -> Float): Float?
inline fun <R : Comparable<R>> ByteArray.maxOfOrNull(selector: (Byte) -> R): R?
inline fun ByteArray.maxOfOrNull(selector: (Byte) -> Double): Double?
inline fun ByteArray.maxOfOrNull(selector: (Byte) -> Float): Float?
inline fun <R : Comparable<R>> CharArray.maxOfOrNull(selector: (Char) -> R): R?
inline fun CharArray.maxOfOrNull(selector: (Char) -> Double): Double?
inline fun CharArray.maxOfOrNull(selector: (Char) -> Float): Float?
inline fun <R : Comparable<R>> DoubleArray.maxOfOrNull(selector: (Double) -> R): R?
inline fun DoubleArray.maxOfOrNull(selector: (Double) -> Double): Double?
inline fun DoubleArray.maxOfOrNull(selector: (Double) -> Float): Float?
inline fun <R : Comparable<R>> FloatArray.maxOfOrNull(selector: (Float) -> R): R?
inline fun FloatArray.maxOfOrNull(selector: (Float) -> Double): Double?
inline fun FloatArray.maxOfOrNull(selector: (Float) -> Float): Float?
inline fun <R : Comparable<R>> IntArray.maxOfOrNull(selector: (Int) -> R): R?
inline fun IntArray.maxOfOrNull(selector: (Int) -> Double): Double?
inline fun IntArray.maxOfOrNull(selector: (Int) -> Float): Float?
inline fun <R : Comparable<R>> LongArray.maxOfOrNull(selector: (Long) -> R): R?
inline fun LongArray.maxOfOrNull(selector: (Long) -> Double): Double?
inline fun LongArray.maxOfOrNull(selector: (Long) -> Float): Float?
inline fun <R : Comparable<R>> ShortArray.maxOfOrNull(selector: (Short) -> R): R?
inline fun ShortArray.maxOfOrNull(selector: (Short) -> Double): Double?
inline fun ShortArray.maxOfOrNull(selector: (Short) -> Float): Float?
inline fun <R : Comparable<R>> UByteArray.maxOfOrNull(selector: (UByte) -> R): R?
inline fun UByteArray.maxOfOrNull(selector: (UByte) -> Double): Double?
inline fun UByteArray.maxOfOrNull(selector: (UByte) -> Float): Float?
inline fun <R : Comparable<R>> UIntArray.maxOfOrNull(selector: (UInt) -> R): R?
inline fun UIntArray.maxOfOrNull(selector: (UInt) -> Double): Double?
inline fun UIntArray.maxOfOrNull(selector: (UInt) -> Float): Float?
inline fun <R : Comparable<R>> ULongArray.maxOfOrNull(selector: (ULong) -> R): R?
inline fun ULongArray.maxOfOrNull(selector: (ULong) -> Double): Double?
inline fun ULongArray.maxOfOrNull(selector: (ULong) -> Float): Float?
inline fun <R : Comparable<R>> UShortArray.maxOfOrNull(selector: (UShort) -> R): R?
inline fun UShortArray.maxOfOrNull(selector: (UShort) -> Double): Double?
inline fun UShortArray.maxOfOrNull(selector: (UShort) -> Float): Float?
inline fun <T, R : Comparable<R>> Iterable<T>.maxOfOrNull(selector: (T) -> R): R?
inline fun <T> Iterable<T>.maxOfOrNull(selector: (T) -> Double): Double?
inline fun <T> Iterable<T>.maxOfOrNull(selector: (T) -> Float): Float?
inline fun <K, V, R : Comparable<R>> Map<out K, V>.maxOfOrNull(selector: (Map.Entry<K, V>) -> R): R?
inline fun <K, V> Map<out K, V>.maxOfOrNull(selector: (Map.Entry<K, V>) -> Double): Double?
inline fun <K, V> Map<out K, V>.maxOfOrNull(selector: (Map.Entry<K, V>) -> Float): Float?
Link copied to clipboard
inline fun <T, R> Array<out T>.maxOfWith(comparator: Comparator<in R>, selector: (T) -> R): R
inline fun <R> BooleanArray.maxOfWith(comparator: Comparator<in R>, selector: (Boolean) -> R): R
inline fun <R> ByteArray.maxOfWith(comparator: Comparator<in R>, selector: (Byte) -> R): R
inline fun <R> CharArray.maxOfWith(comparator: Comparator<in R>, selector: (Char) -> R): R
inline fun <R> DoubleArray.maxOfWith(comparator: Comparator<in R>, selector: (Double) -> R): R
inline fun <R> FloatArray.maxOfWith(comparator: Comparator<in R>, selector: (Float) -> R): R
inline fun <R> IntArray.maxOfWith(comparator: Comparator<in R>, selector: (Int) -> R): R
inline fun <R> LongArray.maxOfWith(comparator: Comparator<in R>, selector: (Long) -> R): R
inline fun <R> ShortArray.maxOfWith(comparator: Comparator<in R>, selector: (Short) -> R): R
inline fun <R> UByteArray.maxOfWith(comparator: Comparator<in R>, selector: (UByte) -> R): R
inline fun <R> UIntArray.maxOfWith(comparator: Comparator<in R>, selector: (UInt) -> R): R
inline fun <R> ULongArray.maxOfWith(comparator: Comparator<in R>, selector: (ULong) -> R): R
inline fun <R> UShortArray.maxOfWith(comparator: Comparator<in R>, selector: (UShort) -> R): R
inline fun <T, R> Iterable<T>.maxOfWith(comparator: Comparator<in R>, selector: (T) -> R): R
inline fun <K, V, R> Map<out K, V>.maxOfWith(comparator: Comparator<in R>, selector: (Map.Entry<K, V>) -> R): R
Link copied to clipboard
inline fun <T, R> Array<out T>.maxOfWithOrNull(comparator: Comparator<in R>, selector: (T) -> R): R?
inline fun <R> BooleanArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Boolean) -> R): R?
inline fun <R> ByteArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Byte) -> R): R?
inline fun <R> CharArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Char) -> R): R?
inline fun <R> DoubleArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Double) -> R): R?
inline fun <R> FloatArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Float) -> R): R?
inline fun <R> IntArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Int) -> R): R?
inline fun <R> LongArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Long) -> R): R?
inline fun <R> ShortArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Short) -> R): R?
inline fun <R> UByteArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (UByte) -> R): R?
inline fun <R> UIntArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (UInt) -> R): R?
inline fun <R> ULongArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (ULong) -> R): R?
inline fun <R> UShortArray.maxOfWithOrNull(comparator: Comparator<in R>, selector: (UShort) -> R): R?
inline fun <T, R> Iterable<T>.maxOfWithOrNull(comparator: Comparator<in R>, selector: (T) -> R): R?
inline fun <K, V, R> Map<out K, V>.maxOfWithOrNull(comparator: Comparator<in R>, selector: (Map.Entry<K, V>) -> R): R?
Link copied to clipboard
fun <T : Comparable<T>> Array<out T>.maxOrNull(): T?
fun DoubleArray.maxOrNull(): Double?
fun FloatArray.maxOrNull(): Float?
fun ByteArray.maxOrNull(): Byte?
fun CharArray.maxOrNull(): Char?
fun DoubleArray.maxOrNull(): Double?
fun FloatArray.maxOrNull(): Float?
fun IntArray.maxOrNull(): Int?
fun LongArray.maxOrNull(): Long?
fun ShortArray.maxOrNull(): Short?
fun UByteArray.maxOrNull(): UByte?
fun UIntArray.maxOrNull(): UInt?
fun ULongArray.maxOrNull(): ULong?
fun UShortArray.maxOrNull(): UShort?
fun <T : Comparable<T>> Iterable<T>.maxOrNull(): T?
fun Iterable<Double>.maxOrNull(): Double?
fun Iterable<Float>.maxOrNull(): Float?
Link copied to clipboard
@JvmName(name = "maxWithOrThrow")
fun <T> Array<out T>.maxWith(comparator: Comparator<in T>): T
@JvmName(name = "maxWithOrThrow")
fun BooleanArray.maxWith(comparator: Comparator<in Boolean>): Boolean
@JvmName(name = "maxWithOrThrow")
fun ByteArray.maxWith(comparator: Comparator<in Byte>): Byte
@JvmName(name = "maxWithOrThrow")
fun CharArray.maxWith(comparator: Comparator<in Char>): Char
@JvmName(name = "maxWithOrThrow")
fun DoubleArray.maxWith(comparator: Comparator<in Double>): Double
@JvmName(name = "maxWithOrThrow")
fun FloatArray.maxWith(comparator: Comparator<in Float>): Float
@JvmName(name = "maxWithOrThrow")
fun IntArray.maxWith(comparator: Comparator<in Int>): Int
@JvmName(name = "maxWithOrThrow")
fun LongArray.maxWith(comparator: Comparator<in Long>): Long
@JvmName(name = "maxWithOrThrow")
fun ShortArray.maxWith(comparator: Comparator<in Short>): Short
@JvmName(name = "maxWithOrThrow-U")
fun UByteArray.maxWith(comparator: Comparator<in UByte>): UByte
@JvmName(name = "maxWithOrThrow-U")
fun UIntArray.maxWith(comparator: Comparator<in UInt>): UInt
@JvmName(name = "maxWithOrThrow-U")
fun ULongArray.maxWith(comparator: Comparator<in ULong>): ULong
@JvmName(name = "maxWithOrThrow-U")
fun UShortArray.maxWith(comparator: Comparator<in UShort>): UShort
@JvmName(name = "maxWithOrThrow")
fun <T> Iterable<T>.maxWith(comparator: Comparator<in T>): T
@JvmName(name = "maxWithOrThrow")
inline fun <K, V> Map<out K, V>.maxWith(comparator: Comparator<in Map.Entry<K, V>>): Map.Entry<K, V>
Link copied to clipboard
fun <T> Array<out T>.maxWithOrNull(comparator: Comparator<in T>): T?
fun BooleanArray.maxWithOrNull(comparator: Comparator<in Boolean>): Boolean?
fun ByteArray.maxWithOrNull(comparator: Comparator<in Byte>): Byte?
fun CharArray.maxWithOrNull(comparator: Comparator<in Char>): Char?
fun DoubleArray.maxWithOrNull(comparator: Comparator<in Double>): Double?
fun FloatArray.maxWithOrNull(comparator: Comparator<in Float>): Float?
fun IntArray.maxWithOrNull(comparator: Comparator<in Int>): Int?
fun LongArray.maxWithOrNull(comparator: Comparator<in Long>): Long?
fun ShortArray.maxWithOrNull(comparator: Comparator<in Short>): Short?
fun UByteArray.maxWithOrNull(comparator: Comparator<in UByte>): UByte?
fun UIntArray.maxWithOrNull(comparator: Comparator<in UInt>): UInt?
fun ULongArray.maxWithOrNull(comparator: Comparator<in ULong>): ULong?
fun UShortArray.maxWithOrNull(comparator: Comparator<in UShort>): UShort?
fun <T> Iterable<T>.maxWithOrNull(comparator: Comparator<in T>): T?
inline fun <K, V> Map<out K, V>.maxWithOrNull(comparator: Comparator<in Map.Entry<K, V>>): Map.Entry<K, V>?
Link copied to clipboard
@JvmName(name = "minOrThrow")
fun <T : Comparable<T>> Array<out T>.min(): T
@JvmName(name = "minOrThrow")
fun DoubleArray.min(): Double
@JvmName(name = "minOrThrow")
fun FloatArray.min(): Float
@JvmName(name = "minOrThrow")
fun ByteArray.min(): Byte
@JvmName(name = "minOrThrow")
fun CharArray.min(): Char
@JvmName(name = "minOrThrow")
fun DoubleArray.min(): Double
@JvmName(name = "minOrThrow")
fun FloatArray.min(): Float
@JvmName(name = "minOrThrow")
fun IntArray.min(): Int
@JvmName(name = "minOrThrow")
fun LongArray.min(): Long
@JvmName(name = "minOrThrow")
fun ShortArray.min(): Short
@JvmName(name = "minOrThrow-U")
fun UByteArray.min(): UByte
@JvmName(name = "minOrThrow-U")
fun UIntArray.min(): UInt
@JvmName(name = "minOrThrow-U")
fun ULongArray.min(): ULong
@JvmName(name = "minOrThrow-U")
fun UShortArray.min(): UShort
@JvmName(name = "minOrThrow")
fun <T : Comparable<T>> Iterable<T>.min(): T
@JvmName(name = "minOrThrow")
fun Iterable<Double>.min(): Double
@JvmName(name = "minOrThrow")
fun Iterable<Float>.min(): Float
Link copied to clipboard
@JvmName(name = "minByOrThrow")
inline fun <T, R : Comparable<R>> Array<out T>.minBy(selector: (T) -> R): T
@JvmName(name = "minByOrThrow")
inline fun <R : Comparable<R>> BooleanArray.minBy(selector: (Boolean) -> R): Boolean
@JvmName(name = "minByOrThrow")
inline fun <R : Comparable<R>> ByteArray.minBy(selector: (Byte) -> R): Byte
@JvmName(name = "minByOrThrow")
inline fun <R : Comparable<R>> CharArray.minBy(selector: (Char) -> R): Char
@JvmName(name = "minByOrThrow")
inline fun <R : Comparable<R>> DoubleArray.minBy(selector: (Double) -> R): Double
@JvmName(name = "minByOrThrow")
inline fun <R : Comparable<R>> FloatArray.minBy(selector: (Float) -> R): Float
@JvmName(name = "minByOrThrow")
inline fun <R : Comparable<R>> IntArray.minBy(selector: (Int) -> R): Int
@JvmName(name = "minByOrThrow")
inline fun <R : Comparable<R>> LongArray.minBy(selector: (Long) -> R): Long
@JvmName(name = "minByOrThrow")
inline fun <R : Comparable<R>> ShortArray.minBy(selector: (Short) -> R): Short
@JvmName(name = "minByOrThrow-U")
inline fun <R : Comparable<R>> UByteArray.minBy(selector: (UByte) -> R): UByte
@JvmName(name = "minByOrThrow-U")
inline fun <R : Comparable<R>> UIntArray.minBy(selector: (UInt) -> R): UInt
@JvmName(name = "minByOrThrow-U")
inline fun <R : Comparable<R>> ULongArray.minBy(selector: (ULong) -> R): ULong
@JvmName(name = "minByOrThrow-U")
inline fun <R : Comparable<R>> UShortArray.minBy(selector: (UShort) -> R): UShort
@JvmName(name = "minByOrThrow")
inline fun <T, R : Comparable<R>> Iterable<T>.minBy(selector: (T) -> R): T
@JvmName(name = "minByOrThrow")
inline fun <K, V, R : Comparable<R>> Map<out K, V>.minBy(selector: (Map.Entry<K, V>) -> R): Map.Entry<K, V>
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.minByOrNull(selector: (T) -> R): T?
inline fun <R : Comparable<R>> BooleanArray.minByOrNull(selector: (Boolean) -> R): Boolean?
inline fun <R : Comparable<R>> ByteArray.minByOrNull(selector: (Byte) -> R): Byte?
inline fun <R : Comparable<R>> CharArray.minByOrNull(selector: (Char) -> R): Char?
inline fun <R : Comparable<R>> DoubleArray.minByOrNull(selector: (Double) -> R): Double?
inline fun <R : Comparable<R>> FloatArray.minByOrNull(selector: (Float) -> R): Float?
inline fun <R : Comparable<R>> IntArray.minByOrNull(selector: (Int) -> R): Int?
inline fun <R : Comparable<R>> LongArray.minByOrNull(selector: (Long) -> R): Long?
inline fun <R : Comparable<R>> ShortArray.minByOrNull(selector: (Short) -> R): Short?
inline fun <R : Comparable<R>> UByteArray.minByOrNull(selector: (UByte) -> R): UByte?
inline fun <R : Comparable<R>> UIntArray.minByOrNull(selector: (UInt) -> R): UInt?
inline fun <R : Comparable<R>> ULongArray.minByOrNull(selector: (ULong) -> R): ULong?
inline fun <R : Comparable<R>> UShortArray.minByOrNull(selector: (UShort) -> R): UShort?
inline fun <T, R : Comparable<R>> Iterable<T>.minByOrNull(selector: (T) -> R): T?
inline fun <K, V, R : Comparable<R>> Map<out K, V>.minByOrNull(selector: (Map.Entry<K, V>) -> R): Map.Entry<K, V>?
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.minOf(selector: (T) -> R): R
inline fun <T> Array<out T>.minOf(selector: (T) -> Double): Double
inline fun <T> Array<out T>.minOf(selector: (T) -> Float): Float
inline fun <R : Comparable<R>> BooleanArray.minOf(selector: (Boolean) -> R): R
inline fun BooleanArray.minOf(selector: (Boolean) -> Double): Double
inline fun BooleanArray.minOf(selector: (Boolean) -> Float): Float
inline fun <R : Comparable<R>> ByteArray.minOf(selector: (Byte) -> R): R
inline fun ByteArray.minOf(selector: (Byte) -> Double): Double
inline fun ByteArray.minOf(selector: (Byte) -> Float): Float
inline fun <R : Comparable<R>> CharArray.minOf(selector: (Char) -> R): R
inline fun CharArray.minOf(selector: (Char) -> Double): Double
inline fun CharArray.minOf(selector: (Char) -> Float): Float
inline fun <R : Comparable<R>> DoubleArray.minOf(selector: (Double) -> R): R
inline fun DoubleArray.minOf(selector: (Double) -> Double): Double
inline fun DoubleArray.minOf(selector: (Double) -> Float): Float
inline fun <R : Comparable<R>> FloatArray.minOf(selector: (Float) -> R): R
inline fun FloatArray.minOf(selector: (Float) -> Double): Double
inline fun FloatArray.minOf(selector: (Float) -> Float): Float
inline fun <R : Comparable<R>> IntArray.minOf(selector: (Int) -> R): R
inline fun IntArray.minOf(selector: (Int) -> Double): Double
inline fun IntArray.minOf(selector: (Int) -> Float): Float
inline fun <R : Comparable<R>> LongArray.minOf(selector: (Long) -> R): R
inline fun LongArray.minOf(selector: (Long) -> Double): Double
inline fun LongArray.minOf(selector: (Long) -> Float): Float
inline fun <R : Comparable<R>> ShortArray.minOf(selector: (Short) -> R): R
inline fun ShortArray.minOf(selector: (Short) -> Double): Double
inline fun ShortArray.minOf(selector: (Short) -> Float): Float
inline fun <R : Comparable<R>> UByteArray.minOf(selector: (UByte) -> R): R
inline fun UByteArray.minOf(selector: (UByte) -> Double): Double
inline fun UByteArray.minOf(selector: (UByte) -> Float): Float
inline fun <R : Comparable<R>> UIntArray.minOf(selector: (UInt) -> R): R
inline fun UIntArray.minOf(selector: (UInt) -> Double): Double
inline fun UIntArray.minOf(selector: (UInt) -> Float): Float
inline fun <R : Comparable<R>> ULongArray.minOf(selector: (ULong) -> R): R
inline fun ULongArray.minOf(selector: (ULong) -> Double): Double
inline fun ULongArray.minOf(selector: (ULong) -> Float): Float
inline fun <R : Comparable<R>> UShortArray.minOf(selector: (UShort) -> R): R
inline fun UShortArray.minOf(selector: (UShort) -> Double): Double
inline fun UShortArray.minOf(selector: (UShort) -> Float): Float
inline fun <T, R : Comparable<R>> Iterable<T>.minOf(selector: (T) -> R): R
inline fun <T> Iterable<T>.minOf(selector: (T) -> Double): Double
inline fun <T> Iterable<T>.minOf(selector: (T) -> Float): Float
inline fun <K, V, R : Comparable<R>> Map<out K, V>.minOf(selector: (Map.Entry<K, V>) -> R): R
inline fun <K, V> Map<out K, V>.minOf(selector: (Map.Entry<K, V>) -> Double): Double
inline fun <K, V> Map<out K, V>.minOf(selector: (Map.Entry<K, V>) -> Float): Float
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.minOfOrNull(selector: (T) -> R): R?
inline fun <T> Array<out T>.minOfOrNull(selector: (T) -> Double): Double?
inline fun <T> Array<out T>.minOfOrNull(selector: (T) -> Float): Float?
inline fun <R : Comparable<R>> BooleanArray.minOfOrNull(selector: (Boolean) -> R): R?
inline fun BooleanArray.minOfOrNull(selector: (Boolean) -> Double): Double?
inline fun BooleanArray.minOfOrNull(selector: (Boolean) -> Float): Float?
inline fun <R : Comparable<R>> ByteArray.minOfOrNull(selector: (Byte) -> R): R?
inline fun ByteArray.minOfOrNull(selector: (Byte) -> Double): Double?
inline fun ByteArray.minOfOrNull(selector: (Byte) -> Float): Float?
inline fun <R : Comparable<R>> CharArray.minOfOrNull(selector: (Char) -> R): R?
inline fun CharArray.minOfOrNull(selector: (Char) -> Double): Double?
inline fun CharArray.minOfOrNull(selector: (Char) -> Float): Float?
inline fun <R : Comparable<R>> DoubleArray.minOfOrNull(selector: (Double) -> R): R?
inline fun DoubleArray.minOfOrNull(selector: (Double) -> Double): Double?
inline fun DoubleArray.minOfOrNull(selector: (Double) -> Float): Float?
inline fun <R : Comparable<R>> FloatArray.minOfOrNull(selector: (Float) -> R): R?
inline fun FloatArray.minOfOrNull(selector: (Float) -> Double): Double?
inline fun FloatArray.minOfOrNull(selector: (Float) -> Float): Float?
inline fun <R : Comparable<R>> IntArray.minOfOrNull(selector: (Int) -> R): R?
inline fun IntArray.minOfOrNull(selector: (Int) -> Double): Double?
inline fun IntArray.minOfOrNull(selector: (Int) -> Float): Float?
inline fun <R : Comparable<R>> LongArray.minOfOrNull(selector: (Long) -> R): R?
inline fun LongArray.minOfOrNull(selector: (Long) -> Double): Double?
inline fun LongArray.minOfOrNull(selector: (Long) -> Float): Float?
inline fun <R : Comparable<R>> ShortArray.minOfOrNull(selector: (Short) -> R): R?
inline fun ShortArray.minOfOrNull(selector: (Short) -> Double): Double?
inline fun ShortArray.minOfOrNull(selector: (Short) -> Float): Float?
inline fun <R : Comparable<R>> UByteArray.minOfOrNull(selector: (UByte) -> R): R?
inline fun UByteArray.minOfOrNull(selector: (UByte) -> Double): Double?
inline fun UByteArray.minOfOrNull(selector: (UByte) -> Float): Float?
inline fun <R : Comparable<R>> UIntArray.minOfOrNull(selector: (UInt) -> R): R?
inline fun UIntArray.minOfOrNull(selector: (UInt) -> Double): Double?
inline fun UIntArray.minOfOrNull(selector: (UInt) -> Float): Float?
inline fun <R : Comparable<R>> ULongArray.minOfOrNull(selector: (ULong) -> R): R?
inline fun ULongArray.minOfOrNull(selector: (ULong) -> Double): Double?
inline fun ULongArray.minOfOrNull(selector: (ULong) -> Float): Float?
inline fun <R : Comparable<R>> UShortArray.minOfOrNull(selector: (UShort) -> R): R?
inline fun UShortArray.minOfOrNull(selector: (UShort) -> Double): Double?
inline fun UShortArray.minOfOrNull(selector: (UShort) -> Float): Float?
inline fun <T, R : Comparable<R>> Iterable<T>.minOfOrNull(selector: (T) -> R): R?
inline fun <T> Iterable<T>.minOfOrNull(selector: (T) -> Double): Double?
inline fun <T> Iterable<T>.minOfOrNull(selector: (T) -> Float): Float?
inline fun <K, V, R : Comparable<R>> Map<out K, V>.minOfOrNull(selector: (Map.Entry<K, V>) -> R): R?
inline fun <K, V> Map<out K, V>.minOfOrNull(selector: (Map.Entry<K, V>) -> Double): Double?
inline fun <K, V> Map<out K, V>.minOfOrNull(selector: (Map.Entry<K, V>) -> Float): Float?
Link copied to clipboard
inline fun <T, R> Array<out T>.minOfWith(comparator: Comparator<in R>, selector: (T) -> R): R
inline fun <R> BooleanArray.minOfWith(comparator: Comparator<in R>, selector: (Boolean) -> R): R
inline fun <R> ByteArray.minOfWith(comparator: Comparator<in R>, selector: (Byte) -> R): R
inline fun <R> CharArray.minOfWith(comparator: Comparator<in R>, selector: (Char) -> R): R
inline fun <R> DoubleArray.minOfWith(comparator: Comparator<in R>, selector: (Double) -> R): R
inline fun <R> FloatArray.minOfWith(comparator: Comparator<in R>, selector: (Float) -> R): R
inline fun <R> IntArray.minOfWith(comparator: Comparator<in R>, selector: (Int) -> R): R
inline fun <R> LongArray.minOfWith(comparator: Comparator<in R>, selector: (Long) -> R): R
inline fun <R> ShortArray.minOfWith(comparator: Comparator<in R>, selector: (Short) -> R): R
inline fun <R> UByteArray.minOfWith(comparator: Comparator<in R>, selector: (UByte) -> R): R
inline fun <R> UIntArray.minOfWith(comparator: Comparator<in R>, selector: (UInt) -> R): R
inline fun <R> ULongArray.minOfWith(comparator: Comparator<in R>, selector: (ULong) -> R): R
inline fun <R> UShortArray.minOfWith(comparator: Comparator<in R>, selector: (UShort) -> R): R
inline fun <T, R> Iterable<T>.minOfWith(comparator: Comparator<in R>, selector: (T) -> R): R
inline fun <K, V, R> Map<out K, V>.minOfWith(comparator: Comparator<in R>, selector: (Map.Entry<K, V>) -> R): R
Link copied to clipboard
inline fun <T, R> Array<out T>.minOfWithOrNull(comparator: Comparator<in R>, selector: (T) -> R): R?
inline fun <R> BooleanArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Boolean) -> R): R?
inline fun <R> ByteArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Byte) -> R): R?
inline fun <R> CharArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Char) -> R): R?
inline fun <R> DoubleArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Double) -> R): R?
inline fun <R> FloatArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Float) -> R): R?
inline fun <R> IntArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Int) -> R): R?
inline fun <R> LongArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Long) -> R): R?
inline fun <R> ShortArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (Short) -> R): R?
inline fun <R> UByteArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (UByte) -> R): R?
inline fun <R> UIntArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (UInt) -> R): R?
inline fun <R> ULongArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (ULong) -> R): R?
inline fun <R> UShortArray.minOfWithOrNull(comparator: Comparator<in R>, selector: (UShort) -> R): R?
inline fun <T, R> Iterable<T>.minOfWithOrNull(comparator: Comparator<in R>, selector: (T) -> R): R?
inline fun <K, V, R> Map<out K, V>.minOfWithOrNull(comparator: Comparator<in R>, selector: (Map.Entry<K, V>) -> R): R?
Link copied to clipboard
fun <T : Comparable<T>> Array<out T>.minOrNull(): T?
fun DoubleArray.minOrNull(): Double?
fun FloatArray.minOrNull(): Float?
fun ByteArray.minOrNull(): Byte?
fun CharArray.minOrNull(): Char?
fun DoubleArray.minOrNull(): Double?
fun FloatArray.minOrNull(): Float?
fun IntArray.minOrNull(): Int?
fun LongArray.minOrNull(): Long?
fun ShortArray.minOrNull(): Short?
fun UByteArray.minOrNull(): UByte?
fun UIntArray.minOrNull(): UInt?
fun ULongArray.minOrNull(): ULong?
fun UShortArray.minOrNull(): UShort?
fun <T : Comparable<T>> Iterable<T>.minOrNull(): T?
fun Iterable<Double>.minOrNull(): Double?
fun Iterable<Float>.minOrNull(): Float?
Link copied to clipboard
operator fun <T> Iterable<T>.minus(element: T): List<T>
operator fun <T> Iterable<T>.minus(elements: Array<out T>): List<T>
operator fun <T> Iterable<T>.minus(elements: Iterable<T>): List<T>
operator fun <T> Iterable<T>.minus(elements: Sequence<T>): List<T>
operator fun <K, V> Map<out K, V>.minus(key: K): Map<K, V>
operator fun <K, V> Map<out K, V>.minus(keys: Array<out K>): Map<K, V>
operator fun <K, V> Map<out K, V>.minus(keys: Iterable<K>): Map<K, V>
operator fun <K, V> Map<out K, V>.minus(keys: Sequence<K>): Map<K, V>
operator fun <T> Set<T>.minus(element: T): Set<T>
operator fun <T> Set<T>.minus(elements: Array<out T>): Set<T>
operator fun <T> Set<T>.minus(elements: Iterable<T>): Set<T>
operator fun <T> Set<T>.minus(elements: Sequence<T>): Set<T>
Link copied to clipboard
inline operator fun <T> MutableCollection<in T>.minusAssign(element: T)
inline operator fun <T> MutableCollection<in T>.minusAssign(elements: Array<T>)
inline operator fun <T> MutableCollection<in T>.minusAssign(elements: Iterable<T>)
inline operator fun <T> MutableCollection<in T>.minusAssign(elements: Sequence<T>)
inline operator fun <K, V> MutableMap<K, V>.minusAssign(key: K)
inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Array<out K>)
inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Iterable<K>)
inline operator fun <K, V> MutableMap<K, V>.minusAssign(keys: Sequence<K>)
Link copied to clipboard
inline fun <T> Iterable<T>.minusElement(element: T): List<T>
inline fun <T> Set<T>.minusElement(element: T): Set<T>
Link copied to clipboard
@JvmName(name = "minWithOrThrow")
fun <T> Array<out T>.minWith(comparator: Comparator<in T>): T
@JvmName(name = "minWithOrThrow")
fun BooleanArray.minWith(comparator: Comparator<in Boolean>): Boolean
@JvmName(name = "minWithOrThrow")
fun ByteArray.minWith(comparator: Comparator<in Byte>): Byte
@JvmName(name = "minWithOrThrow")
fun CharArray.minWith(comparator: Comparator<in Char>): Char
@JvmName(name = "minWithOrThrow")
fun DoubleArray.minWith(comparator: Comparator<in Double>): Double
@JvmName(name = "minWithOrThrow")
fun FloatArray.minWith(comparator: Comparator<in Float>): Float
@JvmName(name = "minWithOrThrow")
fun IntArray.minWith(comparator: Comparator<in Int>): Int
@JvmName(name = "minWithOrThrow")
fun LongArray.minWith(comparator: Comparator<in Long>): Long
@JvmName(name = "minWithOrThrow")
fun ShortArray.minWith(comparator: Comparator<in Short>): Short
@JvmName(name = "minWithOrThrow-U")
fun UByteArray.minWith(comparator: Comparator<in UByte>): UByte
@JvmName(name = "minWithOrThrow-U")
fun UIntArray.minWith(comparator: Comparator<in UInt>): UInt
@JvmName(name = "minWithOrThrow-U")
fun ULongArray.minWith(comparator: Comparator<in ULong>): ULong
@JvmName(name = "minWithOrThrow-U")
fun UShortArray.minWith(comparator: Comparator<in UShort>): UShort
@JvmName(name = "minWithOrThrow")
fun <T> Iterable<T>.minWith(comparator: Comparator<in T>): T
@JvmName(name = "minWithOrThrow")
inline fun <K, V> Map<out K, V>.minWith(comparator: Comparator<in Map.Entry<K, V>>): Map.Entry<K, V>
Link copied to clipboard
fun <T> Array<out T>.minWithOrNull(comparator: Comparator<in T>): T?
fun BooleanArray.minWithOrNull(comparator: Comparator<in Boolean>): Boolean?
fun ByteArray.minWithOrNull(comparator: Comparator<in Byte>): Byte?
fun CharArray.minWithOrNull(comparator: Comparator<in Char>): Char?
fun DoubleArray.minWithOrNull(comparator: Comparator<in Double>): Double?
fun FloatArray.minWithOrNull(comparator: Comparator<in Float>): Float?
fun IntArray.minWithOrNull(comparator: Comparator<in Int>): Int?
fun LongArray.minWithOrNull(comparator: Comparator<in Long>): Long?
fun ShortArray.minWithOrNull(comparator: Comparator<in Short>): Short?
fun UByteArray.minWithOrNull(comparator: Comparator<in UByte>): UByte?
fun UIntArray.minWithOrNull(comparator: Comparator<in UInt>): UInt?
fun ULongArray.minWithOrNull(comparator: Comparator<in ULong>): ULong?
fun UShortArray.minWithOrNull(comparator: Comparator<in UShort>): UShort?
fun <T> Iterable<T>.minWithOrNull(comparator: Comparator<in T>): T?
inline fun <K, V> Map<out K, V>.minWithOrNull(comparator: Comparator<in Map.Entry<K, V>>): Map.Entry<K, V>?
Link copied to clipboard
inline fun <T> MutableList(size: Int, init: (index: Int) -> T): MutableList<T>
Link copied to clipboard
inline fun <T> mutableListOf(): MutableList<T>
fun <T> mutableListOf(vararg elements: T): MutableList<T>
Link copied to clipboard
inline fun <K, V> mutableMapOf(): MutableMap<K, V>
fun <K, V> mutableMapOf(vararg pairs: Pair<K, V>): MutableMap<K, V>
Link copied to clipboard
inline fun <T> mutableSetOf(): MutableSet<T>
fun <T> mutableSetOf(vararg elements: T): MutableSet<T>
Link copied to clipboard
fun <T> Array<out T>.none(): Boolean
fun BooleanArray.none(): Boolean
fun ByteArray.none(): Boolean
fun CharArray.none(): Boolean
fun DoubleArray.none(): Boolean
fun FloatArray.none(): Boolean
fun IntArray.none(): Boolean
fun LongArray.none(): Boolean
fun ShortArray.none(): Boolean
inline fun UByteArray.none(): Boolean
inline fun UIntArray.none(): Boolean
inline fun ULongArray.none(): Boolean
inline fun UShortArray.none(): Boolean
fun <T> Iterable<T>.none(): Boolean
fun <K, V> Map<out K, V>.none(): Boolean
inline fun <T> Array<out T>.none(predicate: (T) -> Boolean): Boolean
inline fun BooleanArray.none(predicate: (Boolean) -> Boolean): Boolean
inline fun ByteArray.none(predicate: (Byte) -> Boolean): Boolean
inline fun CharArray.none(predicate: (Char) -> Boolean): Boolean
inline fun DoubleArray.none(predicate: (Double) -> Boolean): Boolean
inline fun FloatArray.none(predicate: (Float) -> Boolean): Boolean
inline fun IntArray.none(predicate: (Int) -> Boolean): Boolean
inline fun LongArray.none(predicate: (Long) -> Boolean): Boolean
inline fun ShortArray.none(predicate: (Short) -> Boolean): Boolean
inline fun UByteArray.none(predicate: (UByte) -> Boolean): Boolean
inline fun UIntArray.none(predicate: (UInt) -> Boolean): Boolean
inline fun ULongArray.none(predicate: (ULong) -> Boolean): Boolean
inline fun UShortArray.none(predicate: (UShort) -> Boolean): Boolean
inline fun <T> Iterable<T>.none(predicate: (T) -> Boolean): Boolean
inline fun <K, V> Map<out K, V>.none(predicate: (Map.Entry<K, V>) -> Boolean): Boolean
Link copied to clipboard
inline fun <T, C : Iterable<T>> C.onEach(action: (T) -> Unit): C
inline fun <K, V, M : Map<out K, V>> M.onEach(action: (Map.Entry<K, V>) -> Unit): M
inline fun <T> Array<out T>.onEach(action: (T) -> Unit): Array<out T>
inline fun BooleanArray.onEach(action: (Boolean) -> Unit): BooleanArray
inline fun ByteArray.onEach(action: (Byte) -> Unit): ByteArray
inline fun CharArray.onEach(action: (Char) -> Unit): CharArray
inline fun DoubleArray.onEach(action: (Double) -> Unit): DoubleArray
inline fun FloatArray.onEach(action: (Float) -> Unit): FloatArray
inline fun IntArray.onEach(action: (Int) -> Unit): IntArray
inline fun LongArray.onEach(action: (Long) -> Unit): LongArray
inline fun ShortArray.onEach(action: (Short) -> Unit): ShortArray
inline fun UByteArray.onEach(action: (UByte) -> Unit): UByteArray
inline fun UIntArray.onEach(action: (UInt) -> Unit): UIntArray
inline fun ULongArray.onEach(action: (ULong) -> Unit): ULongArray
inline fun UShortArray.onEach(action: (UShort) -> Unit): UShortArray
Link copied to clipboard
inline fun <T, C : Iterable<T>> C.onEachIndexed(action: (index: Int, T) -> Unit): C
inline fun <K, V, M : Map<out K, V>> M.onEachIndexed(action: (index: Int, Map.Entry<K, V>) -> Unit): M
inline fun <T> Array<out T>.onEachIndexed(action: (index: Int, T) -> Unit): Array<out T>
inline fun BooleanArray.onEachIndexed(action: (index: Int, Boolean) -> Unit): BooleanArray
inline fun ByteArray.onEachIndexed(action: (index: Int, Byte) -> Unit): ByteArray
inline fun CharArray.onEachIndexed(action: (index: Int, Char) -> Unit): CharArray
inline fun DoubleArray.onEachIndexed(action: (index: Int, Double) -> Unit): DoubleArray
inline fun FloatArray.onEachIndexed(action: (index: Int, Float) -> Unit): FloatArray
inline fun IntArray.onEachIndexed(action: (index: Int, Int) -> Unit): IntArray
inline fun LongArray.onEachIndexed(action: (index: Int, Long) -> Unit): LongArray
inline fun ShortArray.onEachIndexed(action: (index: Int, Short) -> Unit): ShortArray
inline fun UByteArray.onEachIndexed(action: (index: Int, UByte) -> Unit): UByteArray
inline fun UIntArray.onEachIndexed(action: (index: Int, UInt) -> Unit): UIntArray
inline fun ULongArray.onEachIndexed(action: (index: Int, ULong) -> Unit): ULongArray
inline fun UShortArray.onEachIndexed(action: (index: Int, UShort) -> Unit): UShortArray
Link copied to clipboard
inline fun <T> Array<out T>?.orEmpty(): Array<out T>
inline fun <T> Collection<T>?.orEmpty(): Collection<T>
inline fun <T> List<T>?.orEmpty(): List<T>
inline fun <K, V> Map<K, V>?.orEmpty(): Map<K, V>
inline fun <T> Set<T>?.orEmpty(): Set<T>
Link copied to clipboard
inline fun <T> Array<out T>.partition(predicate: (T) -> Boolean): Pair<List<T>, List<T>>
inline fun BooleanArray.partition(predicate: (Boolean) -> Boolean): Pair<List<Boolean>, List<Boolean>>
inline fun ByteArray.partition(predicate: (Byte) -> Boolean): Pair<List<Byte>, List<Byte>>
inline fun CharArray.partition(predicate: (Char) -> Boolean): Pair<List<Char>, List<Char>>
inline fun DoubleArray.partition(predicate: (Double) -> Boolean): Pair<List<Double>, List<Double>>
inline fun FloatArray.partition(predicate: (Float) -> Boolean): Pair<List<Float>, List<Float>>
inline fun IntArray.partition(predicate: (Int) -> Boolean): Pair<List<Int>, List<Int>>
inline fun LongArray.partition(predicate: (Long) -> Boolean): Pair<List<Long>, List<Long>>
inline fun ShortArray.partition(predicate: (Short) -> Boolean): Pair<List<Short>, List<Short>>
inline fun <T> Iterable<T>.partition(predicate: (T) -> Boolean): Pair<List<T>, List<T>>
Link copied to clipboard
inline operator fun <T> Array<out T>.plus(element: T): Array<T>
inline operator fun <T> Array<out T>.plus(elements: Array<out T>): Array<T>
operator fun <T> Array<out T>.plus(elements: Collection<T>): Array<T>
inline operator fun BooleanArray.plus(element: Boolean): BooleanArray
inline operator fun BooleanArray.plus(elements: BooleanArray): BooleanArray
operator fun BooleanArray.plus(elements: Collection<Boolean>): BooleanArray
inline operator fun ByteArray.plus(element: Byte): ByteArray
inline operator fun ByteArray.plus(elements: ByteArray): ByteArray
operator fun ByteArray.plus(elements: Collection<Byte>): ByteArray
inline operator fun CharArray.plus(element: Char): CharArray
inline operator fun CharArray.plus(elements: CharArray): CharArray
operator fun CharArray.plus(elements: Collection<Char>): CharArray
inline operator fun DoubleArray.plus(element: Double): DoubleArray
inline operator fun DoubleArray.plus(elements: DoubleArray): DoubleArray
operator fun DoubleArray.plus(elements: Collection<Double>): DoubleArray
inline operator fun FloatArray.plus(element: Float): FloatArray
inline operator fun FloatArray.plus(elements: FloatArray): FloatArray
operator fun FloatArray.plus(elements: Collection<Float>): FloatArray
inline operator fun IntArray.plus(element: Int): IntArray
inline operator fun IntArray.plus(elements: IntArray): IntArray
operator fun IntArray.plus(elements: Collection<Int>): IntArray
inline operator fun LongArray.plus(element: Long): LongArray
inline operator fun LongArray.plus(elements: LongArray): LongArray
operator fun LongArray.plus(elements: Collection<Long>): LongArray
inline operator fun ShortArray.plus(element: Short): ShortArray
inline operator fun ShortArray.plus(elements: ShortArray): ShortArray
operator fun ShortArray.plus(elements: Collection<Short>): ShortArray
inline operator fun UByteArray.plus(element: UByte): UByteArray
inline operator fun UByteArray.plus(elements: UByteArray): UByteArray
operator fun UByteArray.plus(elements: Collection<UByte>): UByteArray
inline operator fun UIntArray.plus(element: UInt): UIntArray
inline operator fun UIntArray.plus(elements: UIntArray): UIntArray
operator fun UIntArray.plus(elements: Collection<UInt>): UIntArray
inline operator fun ULongArray.plus(element: ULong): ULongArray
inline operator fun ULongArray.plus(elements: ULongArray): ULongArray
operator fun ULongArray.plus(elements: Collection<ULong>): ULongArray
inline operator fun UShortArray.plus(element: UShort): UShortArray
inline operator fun UShortArray.plus(elements: UShortArray): UShortArray
operator fun UShortArray.plus(elements: Collection<UShort>): UShortArray
operator fun <T> Collection<T>.plus(element: T): List<T>
operator fun <T> Collection<T>.plus(elements: Array<out T>): List<T>
operator fun <T> Collection<T>.plus(elements: Iterable<T>): List<T>
operator fun <T> Collection<T>.plus(elements: Sequence<T>): List<T>
operator fun <T> Iterable<T>.plus(element: T): List<T>
operator fun <T> Iterable<T>.plus(elements: Array<out T>): List<T>
operator fun <T> Iterable<T>.plus(elements: Iterable<T>): List<T>
operator fun <T> Iterable<T>.plus(elements: Sequence<T>): List<T>
operator fun <K, V> Map<out K, V>.plus(pairs: Array<out Pair<K, V>>): Map<K, V>
operator fun <K, V> Map<out K, V>.plus(pair: Pair<K, V>): Map<K, V>
operator fun <K, V> Map<out K, V>.plus(pairs: Iterable<Pair<K, V>>): Map<K, V>
operator fun <K, V> Map<out K, V>.plus(map: Map<out K, V>): Map<K, V>
operator fun <K, V> Map<out K, V>.plus(pairs: Sequence<Pair<K, V>>): Map<K, V>
operator fun <T> Set<T>.plus(element: T): Set<T>
operator fun <T> Set<T>.plus(elements: Array<out T>): Set<T>
operator fun <T> Set<T>.plus(elements: Iterable<T>): Set<T>
operator fun <T> Set<T>.plus(elements: Sequence<T>): Set<T>
Link copied to clipboard
inline operator fun <T> MutableCollection<in T>.plusAssign(element: T)
inline operator fun <T> MutableCollection<in T>.plusAssign(elements: Array<T>)
inline operator fun <T> MutableCollection<in T>.plusAssign(elements: Iterable<T>)
inline operator fun <T> MutableCollection<in T>.plusAssign(elements: Sequence<T>)
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Array<out Pair<K, V>>)
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pair: Pair<K, V>)
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Iterable<Pair<K, V>>)
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(map: Map<K, V>)
inline operator fun <K, V> MutableMap<in K, in V>.plusAssign(pairs: Sequence<Pair<K, V>>)
Link copied to clipboard
inline fun <T> Array<out T>.plusElement(element: T): Array<T>
inline fun <T> Collection<T>.plusElement(element: T): List<T>
inline fun <T> Iterable<T>.plusElement(element: T): List<T>
inline fun <T> Set<T>.plusElement(element: T): Set<T>
Link copied to clipboard
fun <K, V> MutableMap<in K, in V>.putAll(pairs: Array<out Pair<K, V>>)
fun <K, V> MutableMap<in K, in V>.putAll(pairs: Iterable<Pair<K, V>>)
fun <K, V> MutableMap<in K, in V>.putAll(pairs: Sequence<Pair<K, V>>)
Link copied to clipboard
inline fun <T> Array<out T>.random(): T
inline fun BooleanArray.random(): Boolean
inline fun ByteArray.random(): Byte
inline fun CharArray.random(): Char
inline fun DoubleArray.random(): Double
inline fun FloatArray.random(): Float
inline fun IntArray.random(): Int
inline fun LongArray.random(): Long
inline fun ShortArray.random(): Short
inline fun UByteArray.random(): UByte
inline fun UIntArray.random(): UInt
inline fun ULongArray.random(): ULong
inline fun UShortArray.random(): UShort
inline fun <T> Collection<T>.random(): T
fun <T> Array<out T>.random(random: Random): T
fun BooleanArray.random(random: Random): Boolean
fun ByteArray.random(random: Random): Byte
fun CharArray.random(random: Random): Char
fun DoubleArray.random(random: Random): Double
fun FloatArray.random(random: Random): Float
fun IntArray.random(random: Random): Int
fun LongArray.random(random: Random): Long
fun ShortArray.random(random: Random): Short
fun UByteArray.random(random: Random): UByte
fun UIntArray.random(random: Random): UInt
fun ULongArray.random(random: Random): ULong
fun UShortArray.random(random: Random): UShort
fun <T> Collection<T>.random(random: Random): T
Link copied to clipboard
inline fun <T> Array<out T>.randomOrNull(): T?
inline fun BooleanArray.randomOrNull(): Boolean?
inline fun ByteArray.randomOrNull(): Byte?
inline fun CharArray.randomOrNull(): Char?
inline fun DoubleArray.randomOrNull(): Double?
inline fun FloatArray.randomOrNull(): Float?
inline fun IntArray.randomOrNull(): Int?
inline fun LongArray.randomOrNull(): Long?
inline fun ShortArray.randomOrNull(): Short?
inline fun UByteArray.randomOrNull(): UByte?
inline fun UIntArray.randomOrNull(): UInt?
inline fun ULongArray.randomOrNull(): ULong?
inline fun UShortArray.randomOrNull(): UShort?
inline fun <T> Collection<T>.randomOrNull(): T?
fun <T> Array<out T>.randomOrNull(random: Random): T?
fun BooleanArray.randomOrNull(random: Random): Boolean?
fun ByteArray.randomOrNull(random: Random): Byte?
fun CharArray.randomOrNull(random: Random): Char?
fun DoubleArray.randomOrNull(random: Random): Double?
fun FloatArray.randomOrNull(random: Random): Float?
fun IntArray.randomOrNull(random: Random): Int?
fun LongArray.randomOrNull(random: Random): Long?
fun ShortArray.randomOrNull(random: Random): Short?
fun UByteArray.randomOrNull(random: Random): UByte?
fun UIntArray.randomOrNull(random: Random): UInt?
fun ULongArray.randomOrNull(random: Random): ULong?
fun UShortArray.randomOrNull(random: Random): UShort?
fun <T> Collection<T>.randomOrNull(random: Random): T?
Link copied to clipboard
inline fun <S, T : S> Array<out T>.reduce(operation: (acc: S, T) -> S): S
inline fun BooleanArray.reduce(operation: (acc: Boolean, Boolean) -> Boolean): Boolean
inline fun ByteArray.reduce(operation: (acc: Byte, Byte) -> Byte): Byte
inline fun CharArray.reduce(operation: (acc: Char, Char) -> Char): Char
inline fun DoubleArray.reduce(operation: (acc: Double, Double) -> Double): Double
inline fun FloatArray.reduce(operation: (acc: Float, Float) -> Float): Float
inline fun IntArray.reduce(operation: (acc: Int, Int) -> Int): Int
inline fun LongArray.reduce(operation: (acc: Long, Long) -> Long): Long
inline fun ShortArray.reduce(operation: (acc: Short, Short) -> Short): Short
inline fun UByteArray.reduce(operation: (acc: UByte, UByte) -> UByte): UByte
inline fun UIntArray.reduce(operation: (acc: UInt, UInt) -> UInt): UInt
inline fun ULongArray.reduce(operation: (acc: ULong, ULong) -> ULong): ULong
inline fun UShortArray.reduce(operation: (acc: UShort, UShort) -> UShort): UShort
inline fun <S, T : S, K> Grouping<T, K>.reduce(operation: (key: K, accumulator: S, element: T) -> S): Map<K, S>
inline fun <S, T : S> Iterable<T>.reduce(operation: (acc: S, T) -> S): S
Link copied to clipboard
inline fun <S, T : S> Array<out T>.reduceIndexed(operation: (index: Int, acc: S, T) -> S): S
inline fun BooleanArray.reduceIndexed(operation: (index: Int, acc: Boolean, Boolean) -> Boolean): Boolean
inline fun ByteArray.reduceIndexed(operation: (index: Int, acc: Byte, Byte) -> Byte): Byte
inline fun CharArray.reduceIndexed(operation: (index: Int, acc: Char, Char) -> Char): Char
inline fun DoubleArray.reduceIndexed(operation: (index: Int, acc: Double, Double) -> Double): Double
inline fun FloatArray.reduceIndexed(operation: (index: Int, acc: Float, Float) -> Float): Float
inline fun IntArray.reduceIndexed(operation: (index: Int, acc: Int, Int) -> Int): Int
inline fun LongArray.reduceIndexed(operation: (index: Int, acc: Long, Long) -> Long): Long
inline fun ShortArray.reduceIndexed(operation: (index: Int, acc: Short, Short) -> Short): Short
inline fun UByteArray.reduceIndexed(operation: (index: Int, acc: UByte, UByte) -> UByte): UByte
inline fun UIntArray.reduceIndexed(operation: (index: Int, acc: UInt, UInt) -> UInt): UInt
inline fun ULongArray.reduceIndexed(operation: (index: Int, acc: ULong, ULong) -> ULong): ULong
inline fun UShortArray.reduceIndexed(operation: (index: Int, acc: UShort, UShort) -> UShort): UShort
inline fun <S, T : S> Iterable<T>.reduceIndexed(operation: (index: Int, acc: S, T) -> S): S
Link copied to clipboard
inline fun <S, T : S> Array<out T>.reduceIndexedOrNull(operation: (index: Int, acc: S, T) -> S): S?
inline fun BooleanArray.reduceIndexedOrNull(operation: (index: Int, acc: Boolean, Boolean) -> Boolean): Boolean?
inline fun ByteArray.reduceIndexedOrNull(operation: (index: Int, acc: Byte, Byte) -> Byte): Byte?
inline fun CharArray.reduceIndexedOrNull(operation: (index: Int, acc: Char, Char) -> Char): Char?
inline fun DoubleArray.reduceIndexedOrNull(operation: (index: Int, acc: Double, Double) -> Double): Double?
inline fun FloatArray.reduceIndexedOrNull(operation: (index: Int, acc: Float, Float) -> Float): Float?
inline fun IntArray.reduceIndexedOrNull(operation: (index: Int, acc: Int, Int) -> Int): Int?
inline fun LongArray.reduceIndexedOrNull(operation: (index: Int, acc: Long, Long) -> Long): Long?
inline fun ShortArray.reduceIndexedOrNull(operation: (index: Int, acc: Short, Short) -> Short): Short?
inline fun UByteArray.reduceIndexedOrNull(operation: (index: Int, acc: UByte, UByte) -> UByte): UByte?
inline fun UIntArray.reduceIndexedOrNull(operation: (index: Int, acc: UInt, UInt) -> UInt): UInt?
inline fun ULongArray.reduceIndexedOrNull(operation: (index: Int, acc: ULong, ULong) -> ULong): ULong?
inline fun UShortArray.reduceIndexedOrNull(operation: (index: Int, acc: UShort, UShort) -> UShort): UShort?
inline fun <S, T : S> Iterable<T>.reduceIndexedOrNull(operation: (index: Int, acc: S, T) -> S): S?
Link copied to clipboard
inline fun <S, T : S> Array<out T>.reduceOrNull(operation: (acc: S, T) -> S): S?
inline fun BooleanArray.reduceOrNull(operation: (acc: Boolean, Boolean) -> Boolean): Boolean?
inline fun ByteArray.reduceOrNull(operation: (acc: Byte, Byte) -> Byte): Byte?
inline fun CharArray.reduceOrNull(operation: (acc: Char, Char) -> Char): Char?
inline fun DoubleArray.reduceOrNull(operation: (acc: Double, Double) -> Double): Double?
inline fun FloatArray.reduceOrNull(operation: (acc: Float, Float) -> Float): Float?
inline fun IntArray.reduceOrNull(operation: (acc: Int, Int) -> Int): Int?
inline fun LongArray.reduceOrNull(operation: (acc: Long, Long) -> Long): Long?
inline fun ShortArray.reduceOrNull(operation: (acc: Short, Short) -> Short): Short?
inline fun UByteArray.reduceOrNull(operation: (acc: UByte, UByte) -> UByte): UByte?
inline fun UIntArray.reduceOrNull(operation: (acc: UInt, UInt) -> UInt): UInt?
inline fun ULongArray.reduceOrNull(operation: (acc: ULong, ULong) -> ULong): ULong?
inline fun UShortArray.reduceOrNull(operation: (acc: UShort, UShort) -> UShort): UShort?
inline fun <S, T : S> Iterable<T>.reduceOrNull(operation: (acc: S, T) -> S): S?
Link copied to clipboard
inline fun <S, T : S> Array<out T>.reduceRight(operation: (T, acc: S) -> S): S
inline fun BooleanArray.reduceRight(operation: (Boolean, acc: Boolean) -> Boolean): Boolean
inline fun ByteArray.reduceRight(operation: (Byte, acc: Byte) -> Byte): Byte
inline fun CharArray.reduceRight(operation: (Char, acc: Char) -> Char): Char
inline fun DoubleArray.reduceRight(operation: (Double, acc: Double) -> Double): Double
inline fun FloatArray.reduceRight(operation: (Float, acc: Float) -> Float): Float
inline fun IntArray.reduceRight(operation: (Int, acc: Int) -> Int): Int
inline fun LongArray.reduceRight(operation: (Long, acc: Long) -> Long): Long
inline fun ShortArray.reduceRight(operation: (Short, acc: Short) -> Short): Short
inline fun UByteArray.reduceRight(operation: (UByte, acc: UByte) -> UByte): UByte
inline fun UIntArray.reduceRight(operation: (UInt, acc: UInt) -> UInt): UInt
inline fun ULongArray.reduceRight(operation: (ULong, acc: ULong) -> ULong): ULong
inline fun UShortArray.reduceRight(operation: (UShort, acc: UShort) -> UShort): UShort
inline fun <S, T : S> List<T>.reduceRight(operation: (T, acc: S) -> S): S
Link copied to clipboard
inline fun <S, T : S> Array<out T>.reduceRightIndexed(operation: (index: Int, T, acc: S) -> S): S
inline fun BooleanArray.reduceRightIndexed(operation: (index: Int, Boolean, acc: Boolean) -> Boolean): Boolean
inline fun ByteArray.reduceRightIndexed(operation: (index: Int, Byte, acc: Byte) -> Byte): Byte
inline fun CharArray.reduceRightIndexed(operation: (index: Int, Char, acc: Char) -> Char): Char
inline fun DoubleArray.reduceRightIndexed(operation: (index: Int, Double, acc: Double) -> Double): Double
inline fun FloatArray.reduceRightIndexed(operation: (index: Int, Float, acc: Float) -> Float): Float
inline fun IntArray.reduceRightIndexed(operation: (index: Int, Int, acc: Int) -> Int): Int
inline fun LongArray.reduceRightIndexed(operation: (index: Int, Long, acc: Long) -> Long): Long
inline fun ShortArray.reduceRightIndexed(operation: (index: Int, Short, acc: Short) -> Short): Short
inline fun UByteArray.reduceRightIndexed(operation: (index: Int, UByte, acc: UByte) -> UByte): UByte
inline fun UIntArray.reduceRightIndexed(operation: (index: Int, UInt, acc: UInt) -> UInt): UInt
inline fun ULongArray.reduceRightIndexed(operation: (index: Int, ULong, acc: ULong) -> ULong): ULong
inline fun UShortArray.reduceRightIndexed(operation: (index: Int, UShort, acc: UShort) -> UShort): UShort
inline fun <S, T : S> List<T>.reduceRightIndexed(operation: (index: Int, T, acc: S) -> S): S
Link copied to clipboard
inline fun <S, T : S> Array<out T>.reduceRightIndexedOrNull(operation: (index: Int, T, acc: S) -> S): S?
inline fun BooleanArray.reduceRightIndexedOrNull(operation: (index: Int, Boolean, acc: Boolean) -> Boolean): Boolean?
inline fun ByteArray.reduceRightIndexedOrNull(operation: (index: Int, Byte, acc: Byte) -> Byte): Byte?
inline fun CharArray.reduceRightIndexedOrNull(operation: (index: Int, Char, acc: Char) -> Char): Char?
inline fun DoubleArray.reduceRightIndexedOrNull(operation: (index: Int, Double, acc: Double) -> Double): Double?
inline fun FloatArray.reduceRightIndexedOrNull(operation: (index: Int, Float, acc: Float) -> Float): Float?
inline fun IntArray.reduceRightIndexedOrNull(operation: (index: Int, Int, acc: Int) -> Int): Int?
inline fun LongArray.reduceRightIndexedOrNull(operation: (index: Int, Long, acc: Long) -> Long): Long?
inline fun ShortArray.reduceRightIndexedOrNull(operation: (index: Int, Short, acc: Short) -> Short): Short?
inline fun UByteArray.reduceRightIndexedOrNull(operation: (index: Int, UByte, acc: UByte) -> UByte): UByte?
inline fun UIntArray.reduceRightIndexedOrNull(operation: (index: Int, UInt, acc: UInt) -> UInt): UInt?
inline fun ULongArray.reduceRightIndexedOrNull(operation: (index: Int, ULong, acc: ULong) -> ULong): ULong?
inline fun UShortArray.reduceRightIndexedOrNull(operation: (index: Int, UShort, acc: UShort) -> UShort): UShort?
inline fun <S, T : S> List<T>.reduceRightIndexedOrNull(operation: (index: Int, T, acc: S) -> S): S?
Link copied to clipboard
inline fun <S, T : S> Array<out T>.reduceRightOrNull(operation: (T, acc: S) -> S): S?
inline fun BooleanArray.reduceRightOrNull(operation: (Boolean, acc: Boolean) -> Boolean): Boolean?
inline fun ByteArray.reduceRightOrNull(operation: (Byte, acc: Byte) -> Byte): Byte?
inline fun CharArray.reduceRightOrNull(operation: (Char, acc: Char) -> Char): Char?
inline fun DoubleArray.reduceRightOrNull(operation: (Double, acc: Double) -> Double): Double?
inline fun FloatArray.reduceRightOrNull(operation: (Float, acc: Float) -> Float): Float?
inline fun IntArray.reduceRightOrNull(operation: (Int, acc: Int) -> Int): Int?
inline fun LongArray.reduceRightOrNull(operation: (Long, acc: Long) -> Long): Long?
inline fun ShortArray.reduceRightOrNull(operation: (Short, acc: Short) -> Short): Short?
inline fun UByteArray.reduceRightOrNull(operation: (UByte, acc: UByte) -> UByte): UByte?
inline fun UIntArray.reduceRightOrNull(operation: (UInt, acc: UInt) -> UInt): UInt?
inline fun ULongArray.reduceRightOrNull(operation: (ULong, acc: ULong) -> ULong): ULong?
inline fun UShortArray.reduceRightOrNull(operation: (UShort, acc: UShort) -> UShort): UShort?
inline fun <S, T : S> List<T>.reduceRightOrNull(operation: (T, acc: S) -> S): S?
Link copied to clipboard
inline fun <S, T : S, K, M : MutableMap<in K, S>> Grouping<T, K>.reduceTo(destination: M, operation: (key: K, accumulator: S, element: T) -> S): M
Link copied to clipboard
inline fun <T> MutableCollection<out T>.remove(element: T): Boolean
inline fun <T> MutableList<T>.remove(index: Int): T
inline fun <K, V> MutableMap<out K, V>.remove(key: K): V?
Link copied to clipboard
fun <T> MutableCollection<in T>.removeAll(elements: Array<out T>): Boolean
inline fun <T> MutableCollection<out T>.removeAll(elements: Collection<T>): Boolean
fun <T> MutableCollection<in T>.removeAll(elements: Iterable<T>): Boolean
fun <T> MutableCollection<in T>.removeAll(elements: Sequence<T>): Boolean
fun <T> MutableIterable<T>.removeAll(predicate: (T) -> Boolean): Boolean
fun <T> MutableList<T>.removeAll(predicate: (T) -> Boolean): Boolean
Link copied to clipboard
fun <T> MutableList<T>.removeFirst(): T
Link copied to clipboard
fun <T> MutableList<T>.removeFirstOrNull(): T?
Link copied to clipboard
fun <T> MutableList<T>.removeLast(): T
Link copied to clipboard
fun <T> MutableList<T>.removeLastOrNull(): T?
Link copied to clipboard
fun <T : Any> Array<T?>.requireNoNulls(): Array<T>
fun <T : Any> Iterable<T?>.requireNoNulls(): Iterable<T>
fun <T : Any> List<T?>.requireNoNulls(): List<T>
Link copied to clipboard
fun <T> MutableCollection<in T>.retainAll(elements: Array<out T>): Boolean
inline fun <T> MutableCollection<out T>.retainAll(elements: Collection<T>): Boolean
fun <T> MutableCollection<in T>.retainAll(elements: Iterable<T>): Boolean
fun <T> MutableCollection<in T>.retainAll(elements: Sequence<T>): Boolean
fun <T> MutableIterable<T>.retainAll(predicate: (T) -> Boolean): Boolean
fun <T> MutableList<T>.retainAll(predicate: (T) -> Boolean): Boolean
Link copied to clipboard
fun <T> Array<T>.reverse()
fun BooleanArray.reverse()
fun ByteArray.reverse()
fun CharArray.reverse()
fun DoubleArray.reverse()
fun FloatArray.reverse()
fun IntArray.reverse()
fun LongArray.reverse()
fun ShortArray.reverse()
inline fun UByteArray.reverse()
inline fun UIntArray.reverse()
inline fun ULongArray.reverse()
inline fun UShortArray.reverse()
fun <T> MutableList<T>.reverse()
fun <T> Array<T>.reverse(fromIndex: Int, toIndex: Int)
fun BooleanArray.reverse(fromIndex: Int, toIndex: Int)
fun ByteArray.reverse(fromIndex: Int, toIndex: Int)
fun CharArray.reverse(fromIndex: Int, toIndex: Int)
fun DoubleArray.reverse(fromIndex: Int, toIndex: Int)
fun FloatArray.reverse(fromIndex: Int, toIndex: Int)
fun IntArray.reverse(fromIndex: Int, toIndex: Int)
fun LongArray.reverse(fromIndex: Int, toIndex: Int)
fun ShortArray.reverse(fromIndex: Int, toIndex: Int)
inline fun UByteArray.reverse(fromIndex: Int, toIndex: Int)
inline fun UIntArray.reverse(fromIndex: Int, toIndex: Int)
inline fun ULongArray.reverse(fromIndex: Int, toIndex: Int)
inline fun UShortArray.reverse(fromIndex: Int, toIndex: Int)
Link copied to clipboard
fun <T> Array<out T>.reversed(): List<T>
fun BooleanArray.reversed(): List<Boolean>
fun ByteArray.reversed(): List<Byte>
fun CharArray.reversed(): List<Char>
fun DoubleArray.reversed(): List<Double>
fun FloatArray.reversed(): List<Float>
fun IntArray.reversed(): List<Int>
fun LongArray.reversed(): List<Long>
fun ShortArray.reversed(): List<Short>
fun UByteArray.reversed(): List<UByte>
fun UIntArray.reversed(): List<UInt>
fun ULongArray.reversed(): List<ULong>
fun UShortArray.reversed(): List<UShort>
fun <T> Iterable<T>.reversed(): List<T>
Link copied to clipboard
fun <T> Array<T>.reversedArray(): Array<T>
fun BooleanArray.reversedArray(): BooleanArray
fun ByteArray.reversedArray(): ByteArray
fun CharArray.reversedArray(): CharArray
fun DoubleArray.reversedArray(): DoubleArray
fun FloatArray.reversedArray(): FloatArray
fun IntArray.reversedArray(): IntArray
fun LongArray.reversedArray(): LongArray
fun ShortArray.reversedArray(): ShortArray
inline fun UByteArray.reversedArray(): UByteArray
inline fun UIntArray.reversedArray(): UIntArray
inline fun ULongArray.reversedArray(): ULongArray
inline fun UShortArray.reversedArray(): UShortArray
Link copied to clipboard
inline fun <T, R> Array<out T>.runningFold(initial: R, operation: (acc: R, T) -> R): List<R>
inline fun <R> BooleanArray.runningFold(initial: R, operation: (acc: R, Boolean) -> R): List<R>
inline fun <R> ByteArray.runningFold(initial: R, operation: (acc: R, Byte) -> R): List<R>
inline fun <R> CharArray.runningFold(initial: R, operation: (acc: R, Char) -> R): List<R>
inline fun <R> DoubleArray.runningFold(initial: R, operation: (acc: R, Double) -> R): List<R>
inline fun <R> FloatArray.runningFold(initial: R, operation: (acc: R, Float) -> R): List<R>
inline fun <R> IntArray.runningFold(initial: R, operation: (acc: R, Int) -> R): List<R>
inline fun <R> LongArray.runningFold(initial: R, operation: (acc: R, Long) -> R): List<R>
inline fun <R> ShortArray.runningFold(initial: R, operation: (acc: R, Short) -> R): List<R>
inline fun <R> UByteArray.runningFold(initial: R, operation: (acc: R, UByte) -> R): List<R>
inline fun <R> UIntArray.runningFold(initial: R, operation: (acc: R, UInt) -> R): List<R>
inline fun <R> ULongArray.runningFold(initial: R, operation: (acc: R, ULong) -> R): List<R>
inline fun <R> UShortArray.runningFold(initial: R, operation: (acc: R, UShort) -> R): List<R>
inline fun <T, R> Iterable<T>.runningFold(initial: R, operation: (acc: R, T) -> R): List<R>
Link copied to clipboard
inline fun <T, R> Array<out T>.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): List<R>
inline fun <R> BooleanArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Boolean) -> R): List<R>
inline fun <R> ByteArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Byte) -> R): List<R>
inline fun <R> CharArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Char) -> R): List<R>
inline fun <R> DoubleArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Double) -> R): List<R>
inline fun <R> FloatArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Float) -> R): List<R>
inline fun <R> IntArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Int) -> R): List<R>
inline fun <R> LongArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Long) -> R): List<R>
inline fun <R> ShortArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, Short) -> R): List<R>
inline fun <R> UByteArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, UByte) -> R): List<R>
inline fun <R> UIntArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, UInt) -> R): List<R>
inline fun <R> ULongArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, ULong) -> R): List<R>
inline fun <R> UShortArray.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, UShort) -> R): List<R>
inline fun <T, R> Iterable<T>.runningFoldIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): List<R>
Link copied to clipboard
inline fun <S, T : S> Array<out T>.runningReduce(operation: (acc: S, T) -> S): List<S>
inline fun BooleanArray.runningReduce(operation: (acc: Boolean, Boolean) -> Boolean): List<Boolean>
inline fun ByteArray.runningReduce(operation: (acc: Byte, Byte) -> Byte): List<Byte>
inline fun CharArray.runningReduce(operation: (acc: Char, Char) -> Char): List<Char>
inline fun DoubleArray.runningReduce(operation: (acc: Double, Double) -> Double): List<Double>
inline fun FloatArray.runningReduce(operation: (acc: Float, Float) -> Float): List<Float>
inline fun IntArray.runningReduce(operation: (acc: Int, Int) -> Int): List<Int>
inline fun LongArray.runningReduce(operation: (acc: Long, Long) -> Long): List<Long>
inline fun ShortArray.runningReduce(operation: (acc: Short, Short) -> Short): List<Short>
inline fun UByteArray.runningReduce(operation: (acc: UByte, UByte) -> UByte): List<UByte>
inline fun UIntArray.runningReduce(operation: (acc: UInt, UInt) -> UInt): List<UInt>
inline fun ULongArray.runningReduce(operation: (acc: ULong, ULong) -> ULong): List<ULong>
inline fun UShortArray.runningReduce(operation: (acc: UShort, UShort) -> UShort): List<UShort>
inline fun <S, T : S> Iterable<T>.runningReduce(operation: (acc: S, T) -> S): List<S>
Link copied to clipboard
inline fun <S, T : S> Array<out T>.runningReduceIndexed(operation: (index: Int, acc: S, T) -> S): List<S>
inline fun BooleanArray.runningReduceIndexed(operation: (index: Int, acc: Boolean, Boolean) -> Boolean): List<Boolean>
inline fun ByteArray.runningReduceIndexed(operation: (index: Int, acc: Byte, Byte) -> Byte): List<Byte>
inline fun CharArray.runningReduceIndexed(operation: (index: Int, acc: Char, Char) -> Char): List<Char>
inline fun DoubleArray.runningReduceIndexed(operation: (index: Int, acc: Double, Double) -> Double): List<Double>
inline fun FloatArray.runningReduceIndexed(operation: (index: Int, acc: Float, Float) -> Float): List<Float>
inline fun IntArray.runningReduceIndexed(operation: (index: Int, acc: Int, Int) -> Int): List<Int>
inline fun LongArray.runningReduceIndexed(operation: (index: Int, acc: Long, Long) -> Long): List<Long>
inline fun ShortArray.runningReduceIndexed(operation: (index: Int, acc: Short, Short) -> Short): List<Short>
inline fun UByteArray.runningReduceIndexed(operation: (index: Int, acc: UByte, UByte) -> UByte): List<UByte>
inline fun UIntArray.runningReduceIndexed(operation: (index: Int, acc: UInt, UInt) -> UInt): List<UInt>
inline fun ULongArray.runningReduceIndexed(operation: (index: Int, acc: ULong, ULong) -> ULong): List<ULong>
inline fun UShortArray.runningReduceIndexed(operation: (index: Int, acc: UShort, UShort) -> UShort): List<UShort>
inline fun <S, T : S> Iterable<T>.runningReduceIndexed(operation: (index: Int, acc: S, T) -> S): List<S>
Link copied to clipboard
inline fun <T, R> Array<out T>.scan(initial: R, operation: (acc: R, T) -> R): List<R>
inline fun <R> BooleanArray.scan(initial: R, operation: (acc: R, Boolean) -> R): List<R>
inline fun <R> ByteArray.scan(initial: R, operation: (acc: R, Byte) -> R): List<R>
inline fun <R> CharArray.scan(initial: R, operation: (acc: R, Char) -> R): List<R>
inline fun <R> DoubleArray.scan(initial: R, operation: (acc: R, Double) -> R): List<R>
inline fun <R> FloatArray.scan(initial: R, operation: (acc: R, Float) -> R): List<R>
inline fun <R> IntArray.scan(initial: R, operation: (acc: R, Int) -> R): List<R>
inline fun <R> LongArray.scan(initial: R, operation: (acc: R, Long) -> R): List<R>
inline fun <R> ShortArray.scan(initial: R, operation: (acc: R, Short) -> R): List<R>
inline fun <R> UByteArray.scan(initial: R, operation: (acc: R, UByte) -> R): List<R>
inline fun <R> UIntArray.scan(initial: R, operation: (acc: R, UInt) -> R): List<R>
inline fun <R> ULongArray.scan(initial: R, operation: (acc: R, ULong) -> R): List<R>
inline fun <R> UShortArray.scan(initial: R, operation: (acc: R, UShort) -> R): List<R>
inline fun <T, R> Iterable<T>.scan(initial: R, operation: (acc: R, T) -> R): List<R>
Link copied to clipboard
inline fun <T, R> Array<out T>.scanIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): List<R>
inline fun <R> BooleanArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Boolean) -> R): List<R>
inline fun <R> ByteArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Byte) -> R): List<R>
inline fun <R> CharArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Char) -> R): List<R>
inline fun <R> DoubleArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Double) -> R): List<R>
inline fun <R> FloatArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Float) -> R): List<R>
inline fun <R> IntArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Int) -> R): List<R>
inline fun <R> LongArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Long) -> R): List<R>
inline fun <R> ShortArray.scanIndexed(initial: R, operation: (index: Int, acc: R, Short) -> R): List<R>
inline fun <R> UByteArray.scanIndexed(initial: R, operation: (index: Int, acc: R, UByte) -> R): List<R>
inline fun <R> UIntArray.scanIndexed(initial: R, operation: (index: Int, acc: R, UInt) -> R): List<R>
inline fun <R> ULongArray.scanIndexed(initial: R, operation: (index: Int, acc: R, ULong) -> R): List<R>
inline fun <R> UShortArray.scanIndexed(initial: R, operation: (index: Int, acc: R, UShort) -> R): List<R>
inline fun <T, R> Iterable<T>.scanIndexed(initial: R, operation: (index: Int, acc: R, T) -> R): List<R>
Link copied to clipboard
inline operator fun <K, V> MutableMap<K, V>.set(key: K, value: V)
Link copied to clipboard
inline fun <T> setOf(): Set<T>
fun <T> setOf(element: T): Set<T>
fun <T> setOf(vararg elements: T): Set<T>
Link copied to clipboard
fun <T : Any> setOfNotNull(element: T?): Set<T>
fun <T : Any> setOfNotNull(vararg elements: T?): Set<T>
Link copied to clipboard
inline operator fun <V> MutableMap<in String, in V>.setValue(    thisRef: Any?,     property: KProperty<*>,     value: V)
Link copied to clipboard
fun <T> Array<T>.shuffle()
fun BooleanArray.shuffle()
fun ByteArray.shuffle()
fun CharArray.shuffle()
fun DoubleArray.shuffle()
fun FloatArray.shuffle()
fun IntArray.shuffle()
fun LongArray.shuffle()
fun ShortArray.shuffle()
fun UByteArray.shuffle()
fun UIntArray.shuffle()
fun ULongArray.shuffle()
fun UShortArray.shuffle()
fun <T> MutableList<T>.shuffle()
fun <T> Array<T>.shuffle(random: Random)
fun BooleanArray.shuffle(random: Random)
fun ByteArray.shuffle(random: Random)
fun CharArray.shuffle(random: Random)
fun DoubleArray.shuffle(random: Random)
fun FloatArray.shuffle(random: Random)
fun IntArray.shuffle(random: Random)
fun LongArray.shuffle(random: Random)
fun ShortArray.shuffle(random: Random)
fun UByteArray.shuffle(random: Random)
fun UIntArray.shuffle(random: Random)
fun ULongArray.shuffle(random: Random)
fun UShortArray.shuffle(random: Random)
fun <T> MutableList<T>.shuffle(random: Random)
Link copied to clipboard
fun <T> Iterable<T>.shuffled(): List<T>
fun <T> Iterable<T>.shuffled(random: Random): List<T>
Link copied to clipboard
fun <T> Array<out T>.single(): T
fun BooleanArray.single(): Boolean
fun ByteArray.single(): Byte
fun CharArray.single(): Char
fun DoubleArray.single(): Double
fun FloatArray.single(): Float
fun IntArray.single(): Int
fun LongArray.single(): Long
fun ShortArray.single(): Short
inline fun UByteArray.single(): UByte
inline fun UIntArray.single(): UInt
inline fun ULongArray.single(): ULong
inline fun UShortArray.single(): UShort
fun <T> Iterable<T>.single(): T
fun <T> List<T>.single(): T
inline fun <T> Array<out T>.single(predicate: (T) -> Boolean): T
inline fun BooleanArray.single(predicate: (Boolean) -> Boolean): Boolean
inline fun ByteArray.single(predicate: (Byte) -> Boolean): Byte
inline fun CharArray.single(predicate: (Char) -> Boolean): Char
inline fun DoubleArray.single(predicate: (Double) -> Boolean): Double
inline fun FloatArray.single(predicate: (Float) -> Boolean): Float
inline fun IntArray.single(predicate: (Int) -> Boolean): Int
inline fun LongArray.single(predicate: (Long) -> Boolean): Long
inline fun ShortArray.single(predicate: (Short) -> Boolean): Short
inline fun UByteArray.single(predicate: (UByte) -> Boolean): UByte
inline fun UIntArray.single(predicate: (UInt) -> Boolean): UInt
inline fun ULongArray.single(predicate: (ULong) -> Boolean): ULong
inline fun UShortArray.single(predicate: (UShort) -> Boolean): UShort
inline fun <T> Iterable<T>.single(predicate: (T) -> Boolean): T
Link copied to clipboard
fun <T> Array<out T>.singleOrNull(): T?
fun BooleanArray.singleOrNull(): Boolean?
fun ByteArray.singleOrNull(): Byte?
fun CharArray.singleOrNull(): Char?
fun DoubleArray.singleOrNull(): Double?
fun FloatArray.singleOrNull(): Float?
fun IntArray.singleOrNull(): Int?
fun LongArray.singleOrNull(): Long?
fun ShortArray.singleOrNull(): Short?
fun UByteArray.singleOrNull(): UByte?
fun UIntArray.singleOrNull(): UInt?
fun ULongArray.singleOrNull(): ULong?
fun UShortArray.singleOrNull(): UShort?
fun <T> Iterable<T>.singleOrNull(): T?
fun <T> List<T>.singleOrNull(): T?
inline fun <T> Array<out T>.singleOrNull(predicate: (T) -> Boolean): T?
inline fun BooleanArray.singleOrNull(predicate: (Boolean) -> Boolean): Boolean?
inline fun ByteArray.singleOrNull(predicate: (Byte) -> Boolean): Byte?
inline fun CharArray.singleOrNull(predicate: (Char) -> Boolean): Char?
inline fun DoubleArray.singleOrNull(predicate: (Double) -> Boolean): Double?
inline fun FloatArray.singleOrNull(predicate: (Float) -> Boolean): Float?
inline fun IntArray.singleOrNull(predicate: (Int) -> Boolean): Int?
inline fun LongArray.singleOrNull(predicate: (Long) -> Boolean): Long?
inline fun ShortArray.singleOrNull(predicate: (Short) -> Boolean): Short?
inline fun UByteArray.singleOrNull(predicate: (UByte) -> Boolean): UByte?
inline fun UIntArray.singleOrNull(predicate: (UInt) -> Boolean): UInt?
inline fun ULongArray.singleOrNull(predicate: (ULong) -> Boolean): ULong?
inline fun UShortArray.singleOrNull(predicate: (UShort) -> Boolean): UShort?
inline fun <T> Iterable<T>.singleOrNull(predicate: (T) -> Boolean): T?
Link copied to clipboard
fun <T> Array<out T>.slice(indices: Iterable<Int>): List<T>
fun <T> Array<out T>.slice(indices: IntRange): List<T>
fun BooleanArray.slice(indices: Iterable<Int>): List<Boolean>
fun BooleanArray.slice(indices: IntRange): List<Boolean>
fun ByteArray.slice(indices: Iterable<Int>): List<Byte>
fun ByteArray.slice(indices: IntRange): List<Byte>
fun CharArray.slice(indices: Iterable<Int>): List<Char>
fun CharArray.slice(indices: IntRange): List<Char>
fun DoubleArray.slice(indices: Iterable<Int>): List<Double>
fun DoubleArray.slice(indices: IntRange): List<Double>
fun FloatArray.slice(indices: Iterable<Int>): List<Float>
fun FloatArray.slice(indices: IntRange): List<Float>
fun IntArray.slice(indices: Iterable<Int>): List<Int>
fun IntArray.slice(indices: IntRange): List<Int>
fun LongArray.slice(indices: Iterable<Int>): List<Long>
fun LongArray.slice(indices: IntRange): List<Long>
fun ShortArray.slice(indices: Iterable<Int>): List<Short>
fun ShortArray.slice(indices: IntRange): List<Short>
fun UByteArray.slice(indices: Iterable<Int>): List<UByte>
fun UByteArray.slice(indices: IntRange): List<UByte>
fun UIntArray.slice(indices: Iterable<Int>): List<UInt>
fun UIntArray.slice(indices: IntRange): List<UInt>
fun ULongArray.slice(indices: Iterable<Int>): List<ULong>
fun ULongArray.slice(indices: IntRange): List<ULong>
fun UShortArray.slice(indices: Iterable<Int>): List<UShort>
fun UShortArray.slice(indices: IntRange): List<UShort>
fun <T> List<T>.slice(indices: Iterable<Int>): List<T>
fun <T> List<T>.slice(indices: IntRange): List<T>
Link copied to clipboard
fun <T> Array<T>.sliceArray(indices: Collection<Int>): Array<T>
fun <T> Array<T>.sliceArray(indices: IntRange): Array<T>
fun BooleanArray.sliceArray(indices: Collection<Int>): BooleanArray
fun BooleanArray.sliceArray(indices: IntRange): BooleanArray
fun ByteArray.sliceArray(indices: Collection<Int>): ByteArray
fun ByteArray.sliceArray(indices: IntRange): ByteArray
fun CharArray.sliceArray(indices: Collection<Int>): CharArray
fun CharArray.sliceArray(indices: IntRange): CharArray
fun DoubleArray.sliceArray(indices: Collection<Int>): DoubleArray
fun DoubleArray.sliceArray(indices: IntRange): DoubleArray
fun FloatArray.sliceArray(indices: Collection<Int>): FloatArray
fun FloatArray.sliceArray(indices: IntRange): FloatArray
fun IntArray.sliceArray(indices: Collection<Int>): IntArray
fun IntArray.sliceArray(indices: IntRange): IntArray
fun LongArray.sliceArray(indices: Collection<Int>): LongArray
fun LongArray.sliceArray(indices: IntRange): LongArray
fun ShortArray.sliceArray(indices: Collection<Int>): ShortArray
fun ShortArray.sliceArray(indices: IntRange): ShortArray
fun UByteArray.sliceArray(indices: Collection<Int>): UByteArray
fun UByteArray.sliceArray(indices: IntRange): UByteArray
fun UIntArray.sliceArray(indices: Collection<Int>): UIntArray
fun UIntArray.sliceArray(indices: IntRange): UIntArray
fun ULongArray.sliceArray(indices: Collection<Int>): ULongArray
fun ULongArray.sliceArray(indices: IntRange): ULongArray
fun UShortArray.sliceArray(indices: Collection<Int>): UShortArray
fun UShortArray.sliceArray(indices: IntRange): UShortArray
Link copied to clipboard
fun <T : Comparable<T>> Array<out T>.sort()
fun ByteArray.sort()
fun CharArray.sort()
fun DoubleArray.sort()
fun FloatArray.sort()
fun IntArray.sort()
fun LongArray.sort()
fun ShortArray.sort()
fun UByteArray.sort()
fun UIntArray.sort()
fun ULongArray.sort()
fun UShortArray.sort()
fun <T : Comparable<T>> MutableList<T>.sort()
@DeprecatedSinceKotlin(warningSince = "1.6")
fun <T> Array<out T>.sort(comparison: (a: T, b: T) -> Int)
fun <T : Comparable<T>> Array<out T>.sort(fromIndex: Int)
@DeprecatedSinceKotlin(warningSince = "1.6")
inline fun ByteArray.sort(noinline comparison: (a: Byte, b: Byte) -> Int)
fun ByteArray.sort(fromIndex: Int)
@DeprecatedSinceKotlin(warningSince = "1.6")
inline fun CharArray.sort(noinline comparison: (a: Char, b: Char) -> Int)
fun CharArray.sort(fromIndex: Int)
@DeprecatedSinceKotlin(warningSince = "1.6")
inline fun DoubleArray.sort(noinline comparison: (a: Double, b: Double) -> Int)
fun DoubleArray.sort(fromIndex: Int)
@DeprecatedSinceKotlin(warningSince = "1.6")
inline fun FloatArray.sort(noinline comparison: (a: Float, b: Float) -> Int)
fun FloatArray.sort(fromIndex: Int)
@DeprecatedSinceKotlin(warningSince = "1.6")
inline fun IntArray.sort(noinline comparison: (a: Int, b: Int) -> Int)
fun IntArray.sort(fromIndex: Int)
@DeprecatedSinceKotlin(warningSince = "1.6")
inline fun LongArray.sort(noinline comparison: (a: Long, b: Long) -> Int)
fun LongArray.sort(fromIndex: Int)
@DeprecatedSinceKotlin(warningSince = "1.6")
inline fun ShortArray.sort(noinline comparison: (a: Short, b: Short) -> Int)
fun ShortArray.sort(fromIndex: Int)
fun UByteArray.sort(fromIndex: Int)
fun UIntArray.sort(fromIndex: Int)
fun ULongArray.sort(fromIndex: Int)
fun UShortArray.sort(fromIndex: Int)
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.sortBy(crossinline selector: (T) -> R?)
inline fun <T, R : Comparable<R>> MutableList<T>.sortBy(crossinline selector: (T) -> R?)
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.sortByDescending(crossinline selector: (T) -> R?)
inline fun <T, R : Comparable<R>> MutableList<T>.sortByDescending(crossinline selector: (T) -> R?)
Link copied to clipboard
fun <T : Comparable<T>> Array<out T>.sortDescending()
fun ByteArray.sortDescending()
fun CharArray.sortDescending()
fun DoubleArray.sortDescending()
fun FloatArray.sortDescending()
fun IntArray.sortDescending()
fun LongArray.sortDescending()
fun ShortArray.sortDescending()
fun UByteArray.sortDescending()
fun UIntArray.sortDescending()
fun ULongArray.sortDescending()
fun UShortArray.sortDescending()
fun <T : Comparable<T>> MutableList<T>.sortDescending()
fun <T : Comparable<T>> Array<out T>.sortDescending(fromIndex: Int, toIndex: Int)
fun ByteArray.sortDescending(fromIndex: Int, toIndex: Int)
fun CharArray.sortDescending(fromIndex: Int, toIndex: Int)
fun DoubleArray.sortDescending(fromIndex: Int, toIndex: Int)
fun FloatArray.sortDescending(fromIndex: Int, toIndex: Int)
fun IntArray.sortDescending(fromIndex: Int, toIndex: Int)
fun LongArray.sortDescending(fromIndex: Int, toIndex: Int)
fun ShortArray.sortDescending(fromIndex: Int, toIndex: Int)
fun UByteArray.sortDescending(fromIndex: Int, toIndex: Int)
fun UIntArray.sortDescending(fromIndex: Int, toIndex: Int)
fun ULongArray.sortDescending(fromIndex: Int, toIndex: Int)
fun UShortArray.sortDescending(fromIndex: Int, toIndex: Int)
Link copied to clipboard
fun <T : Comparable<T>> Array<out T>.sorted(): List<T>
fun ByteArray.sorted(): List<Byte>
fun CharArray.sorted(): List<Char>
fun DoubleArray.sorted(): List<Double>
fun FloatArray.sorted(): List<Float>
fun IntArray.sorted(): List<Int>
fun LongArray.sorted(): List<Long>
fun ShortArray.sorted(): List<Short>
fun UByteArray.sorted(): List<UByte>
fun UIntArray.sorted(): List<UInt>
fun ULongArray.sorted(): List<ULong>
fun UShortArray.sorted(): List<UShort>
fun <T : Comparable<T>> Iterable<T>.sorted(): List<T>
Link copied to clipboard
fun <T : Comparable<T>> Array<T>.sortedArray(): Array<T>
fun ByteArray.sortedArray(): ByteArray
fun CharArray.sortedArray(): CharArray
fun DoubleArray.sortedArray(): DoubleArray
fun FloatArray.sortedArray(): FloatArray
fun IntArray.sortedArray(): IntArray
fun LongArray.sortedArray(): LongArray
fun ShortArray.sortedArray(): ShortArray
fun UIntArray.sortedArray(): UIntArray
Link copied to clipboard
fun <T : Comparable<T>> Array<T>.sortedArrayDescending(): Array<T>
fun ByteArray.sortedArrayDescending(): ByteArray
fun CharArray.sortedArrayDescending(): CharArray
fun DoubleArray.sortedArrayDescending(): DoubleArray
fun FloatArray.sortedArrayDescending(): FloatArray
fun IntArray.sortedArrayDescending(): IntArray
fun LongArray.sortedArrayDescending(): LongArray
fun ShortArray.sortedArrayDescending(): ShortArray
Link copied to clipboard
fun <T> Array<out T>.sortedArrayWith(comparator: Comparator<in T>): Array<out T>
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.sortedBy(crossinline selector: (T) -> R?): List<T>
inline fun <R : Comparable<R>> BooleanArray.sortedBy(crossinline selector: (Boolean) -> R?): List<Boolean>
inline fun <R : Comparable<R>> ByteArray.sortedBy(crossinline selector: (Byte) -> R?): List<Byte>
inline fun <R : Comparable<R>> CharArray.sortedBy(crossinline selector: (Char) -> R?): List<Char>
inline fun <R : Comparable<R>> DoubleArray.sortedBy(crossinline selector: (Double) -> R?): List<Double>
inline fun <R : Comparable<R>> FloatArray.sortedBy(crossinline selector: (Float) -> R?): List<Float>
inline fun <R : Comparable<R>> IntArray.sortedBy(crossinline selector: (Int) -> R?): List<Int>
inline fun <R : Comparable<R>> LongArray.sortedBy(crossinline selector: (Long) -> R?): List<Long>
inline fun <R : Comparable<R>> ShortArray.sortedBy(crossinline selector: (Short) -> R?): List<Short>
inline fun <T, R : Comparable<R>> Iterable<T>.sortedBy(crossinline selector: (T) -> R?): List<T>
Link copied to clipboard
inline fun <T, R : Comparable<R>> Array<out T>.sortedByDescending(crossinline selector: (T) -> R?): List<T>
inline fun <R : Comparable<R>> BooleanArray.sortedByDescending(crossinline selector: (Boolean) -> R?): List<Boolean>
inline fun <R : Comparable<R>> ByteArray.sortedByDescending(crossinline selector: (Byte) -> R?): List<Byte>
inline fun <R : Comparable<R>> CharArray.sortedByDescending(crossinline selector: (Char) -> R?): List<Char>
inline fun <R : Comparable<R>> DoubleArray.sortedByDescending(crossinline selector: (Double) -> R?): List<Double>
inline fun <R : Comparable<R>> FloatArray.sortedByDescending(crossinline selector: (Float) -> R?): List<Float>
inline fun <R : Comparable<R>> IntArray.sortedByDescending(crossinline selector: (Int) -> R?): List<Int>
inline fun <R : Comparable<R>> LongArray.sortedByDescending(crossinline selector: (Long) -> R?): List<Long>
inline fun <R : Comparable<R>> ShortArray.sortedByDescending(crossinline selector: (Short) -> R?): List<Short>
inline fun <T, R : Comparable<R>> Iterable<T>.sortedByDescending(crossinline selector: (T) -> R?): List<T>
Link copied to clipboard
fun <T : Comparable<T>> Array<out T>.sortedDescending(): List<T>
fun ByteArray.sortedDescending(): List<Byte>
fun CharArray.sortedDescending(): List<Char>
fun DoubleArray.sortedDescending(): List<Double>
fun FloatArray.sortedDescending(): List<Float>
fun IntArray.sortedDescending(): List<Int>
fun LongArray.sortedDescending(): List<Long>
fun ShortArray.sortedDescending(): List<Short>
fun UIntArray.sortedDescending(): List<UInt>
fun <T : Comparable<T>> Iterable<T>.sortedDescending(): List<T>
Link copied to clipboard
fun <T> Array<out T>.sortedWith(comparator: Comparator<in T>): List<T>
fun BooleanArray.sortedWith(comparator: Comparator<in Boolean>): List<Boolean>
fun ByteArray.sortedWith(comparator: Comparator<in Byte>): List<Byte>
fun CharArray.sortedWith(comparator: Comparator<in Char>): List<Char>
fun DoubleArray.sortedWith(comparator: Comparator<in Double>): List<Double>
fun FloatArray.sortedWith(comparator: Comparator<in Float>): List<Float>
fun IntArray.sortedWith(comparator: Comparator<in Int>): List<Int>
fun LongArray.sortedWith(comparator: Comparator<in Long>): List<Long>
fun ShortArray.sortedWith(comparator: Comparator<in Short>): List<Short>
fun <T> Iterable<T>.sortedWith(comparator: Comparator<in T>): List<T>
Link copied to clipboard
fun <T> Array<out T>.sortWith(comparator: Comparator<in T>)
fun <T> MutableList<T>.sortWith(comparator: Comparator<in T>)
fun <T> Array<out T>.sortWith(comparator: Comparator<in T>, fromIndex: Int)
Link copied to clipboard
fun <V> stringMapOf(vararg pairs: Pair<String, V>): HashMap<String, V>
Link copied to clipboard
fun stringSetOf(vararg elements: String): HashSet<String>
Link copied to clipboard
infix fun <T> Array<out T>.subtract(other: Iterable<T>): Set<T>
infix fun BooleanArray.subtract(other: Iterable<Boolean>): Set<Boolean>
infix fun ByteArray.subtract(other: Iterable<Byte>): Set<Byte>
infix fun CharArray.subtract(other: Iterable<Char>): Set<Char>
infix fun DoubleArray.subtract(other: Iterable<Double>): Set<Double>
infix fun FloatArray.subtract(other: Iterable<Float>): Set<Float>
infix fun IntArray.subtract(other: Iterable<Int>): Set<Int>
infix fun LongArray.subtract(other: Iterable<Long>): Set<Long>
infix fun ShortArray.subtract(other: Iterable<Short>): Set<Short>
infix fun <T> Iterable<T>.subtract(other: Iterable<T>): Set<T>
Link copied to clipboard
@JvmName(name = "sumOfByte")
fun ByteArray.sum(): Int
@JvmName(name = "sumOfDouble")
fun DoubleArray.sum(): Double
@JvmName(name = "sumOfFloat")
fun FloatArray.sum(): Float
@JvmName(name = "sumOfInt")
fun IntArray.sum(): Int
@JvmName(name = "sumOfLong")
fun LongArray.sum(): Long
@JvmName(name = "sumOfShort")
fun ShortArray.sum(): Int
@JvmName(name = "sumOfUByte")
fun Array<out UByte>.sum(): UInt
@JvmName(name = "sumOfUInt")
fun Array<out UInt>.sum(): UInt
@JvmName(name = "sumOfULong")
fun Array<out ULong>.sum(): ULong
@JvmName(name = "sumOfUShort")
fun Array<out UShort>.sum(): UInt
fun ByteArray.sum(): Int
fun DoubleArray.sum(): Double
fun FloatArray.sum(): Float
fun IntArray.sum(): Int
fun LongArray.sum(): Long
fun ShortArray.sum(): Int
inline fun UByteArray.sum(): UInt
inline fun UIntArray.sum(): UInt
inline fun ULongArray.sum(): ULong
inline fun UShortArray.sum(): UInt
@JvmName(name = "sumOfByte")
fun Iterable<Byte>.sum(): Int
@JvmName(name = "sumOfDouble")
fun Iterable<Double>.sum(): Double
@JvmName(name = "sumOfFloat")
fun Iterable<Float>.sum(): Float
@JvmName(name = "sumOfInt")
fun Iterable<Int>.sum(): Int
@JvmName(name = "sumOfLong")
fun Iterable<Long>.sum(): Long
@JvmName(name = "sumOfShort")
fun Iterable<Short>.sum(): Int
@JvmName(name = "sumOfUByte")
fun Iterable<UByte>.sum(): UInt
@JvmName(name = "sumOfUInt")
fun Iterable<UInt>.sum(): UInt
@JvmName(name = "sumOfULong")
fun Iterable<ULong>.sum(): ULong
@JvmName(name = "sumOfUShort")
fun Iterable<UShort>.sum(): UInt
Link copied to clipboard
@DeprecatedSinceKotlin(warningSince = "1.5")
inline fun <T> Array<out T>.sumBy(selector: (T) -> Int): Int
@DeprecatedSinceKotlin(warningSince = "1.5")
inline fun BooleanArray.sumBy(selector: (Boolean) -> Int): Int
@DeprecatedSinceKotlin(warningSince = "1.5")
inline fun ByteArray.sumBy(selector: (Byte) -> Int): Int
@DeprecatedSinceKotlin(warningSince = "1.5")
inline fun CharArray.sumBy(selector: (Char) -> Int): Int
@DeprecatedSinceKotlin(warningSince = "1.5")
inline fun DoubleArray.sumBy(selector: (Double) -> Int): Int
@DeprecatedSinceKotlin(warningSince = "1.5")
inline fun FloatArray.sumBy(selector: (Float) -> Int): Int
@DeprecatedSinceKotlin(warningSince = "1.5")
inline fun IntArray.sumBy(selector: (Int) -> Int): Int
@DeprecatedSinceKotlin(warningSince = "1.5")
inline fun LongArray.sumBy(selector: (Long) -> Int): Int
@DeprecatedSinceKotlin(warningSince = "1.5")
inline fun ShortArray.sumBy(selector: (Short) -> Int): Int
inline fun UByteArray.sumBy(selector: (UByte) -> UInt): UInt
inline fun UIntArray.sumBy(selector: (UInt) -> UInt): UInt
inline fun ULongArray.sumBy(selector: (ULong) -> UInt): UInt
inline fun UShortArray.sumBy(selector: (UShort) -> UInt): UInt
@DeprecatedSinceKotlin(warningSince = "1.5")
inline fun <T> Iterable<T>.sumBy(selector: (T) -> Int): Int
Link copied to clipboard
@DeprecatedSinceKotlin(warningSince = "1.5")
inline fun <T> Array<out T>.sumByDouble(selector: (T) -> Double): Double
@DeprecatedSinceKotlin(warningSince = "1.5")
inline fun BooleanArray.sumByDouble(selector: (Boolean) -> Double): Double
@DeprecatedSinceKotlin(warningSince = "1.5")
inline fun ByteArray.sumByDouble(selector: (Byte) -> Double): Double
@DeprecatedSinceKotlin(warningSince = "1.5")
inline fun CharArray.sumByDouble(selector: (Char) -> Double): Double
@DeprecatedSinceKotlin(warningSince = "1.5")
inline fun DoubleArray.sumByDouble(selector: (Double) -> Double): Double
@DeprecatedSinceKotlin(warningSince = "1.5")
inline fun FloatArray.sumByDouble(selector: (Float) -> Double): Double
@DeprecatedSinceKotlin(warningSince = "1.5")
inline fun IntArray.sumByDouble(selector: (Int) -> Double): Double
@DeprecatedSinceKotlin(warningSince = "1.5")
inline fun LongArray.sumByDouble(selector: (Long) -> Double): Double
@DeprecatedSinceKotlin(warningSince = "1.5")
inline fun ShortArray.sumByDouble(selector: (Short) -> Double): Double
inline fun UByteArray.sumByDouble(selector: (UByte) -> Double): Double
inline fun UIntArray.sumByDouble(selector: (UInt) -> Double): Double
inline fun ULongArray.sumByDouble(selector: (ULong) -> Double): Double
inline fun UShortArray.sumByDouble(selector: (UShort) -> Double): Double
@DeprecatedSinceKotlin(warningSince = "1.5")
inline fun <T> Iterable<T>.sumByDouble(selector: (T) -> Double): Double
Link copied to clipboard
@JvmName(name = "sumOfDouble")
inline fun <T> Array<out T>.sumOf(selector: (T) -> Double): Double
@JvmName(name = "sumOfInt")
inline fun <T> Array<out T>.sumOf(selector: (T) -> Int): Int
@JvmName(name = "sumOfLong")
inline fun <T> Array<out T>.sumOf(selector: (T) -> Long): Long
@JvmName(name = "sumOfUInt")
inline fun <T> Array<out T>.sumOf(selector: (T) -> UInt): UInt
@JvmName(name = "sumOfULong")
inline fun <T> Array<out T>.sumOf(selector: (T) -> ULong): ULong
@JvmName(name = "sumOfDouble")
inline fun BooleanArray.sumOf(selector: (Boolean) -> Double): Double
@JvmName(name = "sumOfInt")
inline fun BooleanArray.sumOf(selector: (Boolean) -> Int): Int
@JvmName(name = "sumOfLong")
inline fun BooleanArray.sumOf(selector: (Boolean) -> Long): Long
@JvmName(name = "sumOfUInt")
inline fun BooleanArray.sumOf(selector: (Boolean) -> UInt): UInt
@JvmName(name = "sumOfULong")
inline fun BooleanArray.sumOf(selector: (Boolean) -> ULong): ULong
@JvmName(name = "sumOfDouble")
inline fun ByteArray.sumOf(selector: (Byte) -> Double): Double
@JvmName(name = "sumOfInt")
inline fun ByteArray.sumOf(selector: (Byte) -> Int): Int
@JvmName(name = "sumOfLong")
inline fun ByteArray.sumOf(selector: (Byte) -> Long): Long
@JvmName(name = "sumOfUInt")
inline fun ByteArray.sumOf(selector: (Byte) -> UInt): UInt
@JvmName(name = "sumOfULong")
inline fun ByteArray.sumOf(selector: (Byte) -> ULong): ULong
@JvmName(name = "sumOfDouble")
inline fun CharArray.sumOf(selector: (Char) -> Double): Double
@JvmName(name = "sumOfInt")
inline fun CharArray.sumOf(selector: (Char) -> Int): Int
@JvmName(name = "sumOfLong")
inline fun CharArray.sumOf(selector: (Char) -> Long): Long
@JvmName(name = "sumOfUInt")
inline fun CharArray.sumOf(selector: (Char) -> UInt): UInt
@JvmName(name = "sumOfULong")
inline fun CharArray.sumOf(selector: (Char) -> ULong): ULong
@JvmName(name = "sumOfDouble")
inline fun DoubleArray.sumOf(selector: (Double) -> Double): Double
@JvmName(name = "sumOfInt")
inline fun DoubleArray.sumOf(selector: (Double) -> Int): Int
@JvmName(name = "sumOfLong")
inline fun DoubleArray.sumOf(selector: (Double) -> Long): Long
@JvmName(name = "sumOfUInt")
inline fun DoubleArray.sumOf(selector: (Double) -> UInt): UInt
@JvmName(name = "sumOfULong")
inline fun DoubleArray.sumOf(selector: (Double) -> ULong): ULong
@JvmName(name = "sumOfDouble")
inline fun FloatArray.sumOf(selector: (Float) -> Double): Double
@JvmName(name = "sumOfInt")
inline fun FloatArray.sumOf(selector: (Float) -> Int): Int
@JvmName(name = "sumOfLong")
inline fun FloatArray.sumOf(selector: (Float) -> Long): Long
@JvmName(name = "sumOfUInt")
inline fun FloatArray.sumOf(selector: (Float) -> UInt): UInt
@JvmName(name = "sumOfULong")
inline fun FloatArray.sumOf(selector: (Float) -> ULong): ULong
@JvmName(name = "sumOfDouble")
inline fun IntArray.sumOf(selector: (Int) -> Double): Double
@JvmName(name = "sumOfInt")
inline fun IntArray.sumOf(selector: (Int) -> Int): Int
@JvmName(name = "sumOfLong")
inline fun IntArray.sumOf(selector: (Int) -> Long): Long
@JvmName(name = "sumOfUInt")
inline fun IntArray.sumOf(selector: (Int) -> UInt): UInt
@JvmName(name = "sumOfULong")
inline fun IntArray.sumOf(selector: (Int) -> ULong): ULong
@JvmName(name = "sumOfDouble")
inline fun LongArray.sumOf(selector: (Long) -> Double): Double
@JvmName(name = "sumOfInt")
inline fun LongArray.sumOf(selector: (Long) -> Int): Int
@JvmName(name = "sumOfLong")
inline fun LongArray.sumOf(selector: (Long) -> Long): Long
@JvmName(name = "sumOfUInt")
inline fun LongArray.sumOf(selector: (Long) -> UInt): UInt
@JvmName(name = "sumOfULong")
inline fun LongArray.sumOf(selector: (Long) -> ULong): ULong
@JvmName(name = "sumOfDouble")
inline fun ShortArray.sumOf(selector: (Short) -> Double): Double
@JvmName(name = "sumOfInt")
inline fun ShortArray.sumOf(selector: (Short) -> Int): Int
@JvmName(name = "sumOfLong")
inline fun ShortArray.sumOf(selector: (Short) -> Long): Long
@JvmName(name = "sumOfUInt")
inline fun ShortArray.sumOf(selector: (Short) -> UInt): UInt
@JvmName(name = "sumOfULong")
inline fun ShortArray.sumOf(selector: (Short) -> ULong): ULong
@JvmName(name = "sumOfDouble")
inline fun UByteArray.sumOf(selector: (UByte) -> Double): Double
inline fun UByteArray.sumOf(selector: (UByte) -> Int): Int
@JvmName(name = "sumOfLong")
inline fun UByteArray.sumOf(selector: (UByte) -> Long): Long
@JvmName(name = "sumOfUInt")
inline fun UByteArray.sumOf(selector: (UByte) -> UInt): UInt
@JvmName(name = "sumOfULong")
inline fun UByteArray.sumOf(selector: (UByte) -> ULong): ULong
@JvmName(name = "sumOfDouble")
inline fun UIntArray.sumOf(selector: (UInt) -> Double): Double
inline fun UIntArray.sumOf(selector: (UInt) -> Int): Int
@JvmName(name = "sumOfLong")
inline fun UIntArray.sumOf(selector: (UInt) -> Long): Long
@JvmName(name = "sumOfUInt")
inline fun UIntArray.sumOf(selector: (UInt) -> UInt): UInt
@JvmName(name = "sumOfULong")
inline fun UIntArray.sumOf(selector: (UInt) -> ULong): ULong
@JvmName(name = "sumOfDouble")
inline fun ULongArray.sumOf(selector: (ULong) -> Double): Double
inline fun ULongArray.sumOf(selector: (ULong) -> Int): Int
@JvmName(name = "sumOfLong")
inline fun ULongArray.sumOf(selector: (ULong) -> Long): Long
@JvmName(name = "sumOfUInt")
inline fun ULongArray.sumOf(selector: (ULong) -> UInt): UInt
@JvmName(name = "sumOfULong")
inline fun ULongArray.sumOf(selector: (ULong) -> ULong): ULong
@JvmName(name = "sumOfDouble")
inline fun UShortArray.sumOf(selector: (UShort) -> Double): Double
inline fun UShortArray.sumOf(selector: (UShort) -> Int): Int
@JvmName(name = "sumOfLong")
inline fun UShortArray.sumOf(selector: (UShort) -> Long): Long
@JvmName(name = "sumOfUInt")
inline fun UShortArray.sumOf(selector: (UShort) -> UInt): UInt
@JvmName(name = "sumOfULong")
inline fun UShortArray.sumOf(selector: (UShort) -> ULong): ULong
@JvmName(name = "sumOfDouble")
inline fun <T> Iterable<T>.sumOf(selector: (T) -> Double): Double
@JvmName(name = "sumOfInt")
inline fun <T> Iterable<T>.sumOf(selector: (T) -> Int): Int
@JvmName(name = "sumOfLong")
inline fun <T> Iterable<T>.sumOf(selector: (T) -> Long): Long
@JvmName(name = "sumOfUInt")
inline fun <T> Iterable<T>.sumOf(selector: (T) -> UInt): UInt
@JvmName(name = "sumOfULong")
inline fun <T> Iterable<T>.sumOf(selector: (T) -> ULong): ULong
Link copied to clipboard
fun <T> Array<out T>.take(n: Int): List<T>
fun BooleanArray.take(n: Int): List<Boolean>
fun ByteArray.take(n: Int): List<Byte>
fun CharArray.take(n: Int): List<Char>
fun DoubleArray.take(n: Int): List<Double>
fun FloatArray.take(n: Int): List<Float>
fun IntArray.take(n: Int): List<Int>
fun LongArray.take(n: Int): List<Long>
fun ShortArray.take(n: Int): List<Short>
fun UByteArray.take(n: Int): List<UByte>
fun UIntArray.take(n: Int): List<UInt>
fun ULongArray.take(n: Int): List<ULong>
fun UShortArray.take(n: Int): List<UShort>
fun <T> Iterable<T>.take(n: Int): List<T>
Link copied to clipboard
fun <T> Array<out T>.takeLast(n: Int): List<T>
fun BooleanArray.takeLast(n: Int): List<Boolean>
fun ByteArray.takeLast(n: Int): List<Byte>
fun CharArray.takeLast(n: Int): List<Char>
fun DoubleArray.takeLast(n: Int): List<Double>
fun FloatArray.takeLast(n: Int): List<Float>
fun IntArray.takeLast(n: Int): List<Int>
fun LongArray.takeLast(n: Int): List<Long>
fun ShortArray.takeLast(n: Int): List<Short>
fun UByteArray.takeLast(n: Int): List<UByte>
fun UIntArray.takeLast(n: Int): List<UInt>
fun ULongArray.takeLast(n: Int): List<ULong>
fun UShortArray.takeLast(n: Int): List<UShort>
fun <T> List<T>.takeLast(n: Int): List<T>
Link copied to clipboard
inline fun <T> Array<out T>.takeLastWhile(predicate: (T) -> Boolean): List<T>
inline fun BooleanArray.takeLastWhile(predicate: (Boolean) -> Boolean): List<Boolean>
inline fun ByteArray.takeLastWhile(predicate: (Byte) -> Boolean): List<Byte>
inline fun CharArray.takeLastWhile(predicate: (Char) -> Boolean): List<Char>
inline fun DoubleArray.takeLastWhile(predicate: (Double) -> Boolean): List<Double>
inline fun FloatArray.takeLastWhile(predicate: (Float) -> Boolean): List<Float>
inline fun IntArray.takeLastWhile(predicate: (Int) -> Boolean): List<Int>
inline fun LongArray.takeLastWhile(predicate: (Long) -> Boolean): List<Long>
inline fun ShortArray.takeLastWhile(predicate: (Short) -> Boolean): List<Short>
inline fun UByteArray.takeLastWhile(predicate: (UByte) -> Boolean): List<UByte>
inline fun UIntArray.takeLastWhile(predicate: (UInt) -> Boolean): List<UInt>
inline fun ULongArray.takeLastWhile(predicate: (ULong) -> Boolean): List<ULong>
inline fun UShortArray.takeLastWhile(predicate: (UShort) -> Boolean): List<UShort>
inline fun <T> List<T>.takeLastWhile(predicate: (T) -> Boolean): List<T>
Link copied to clipboard
inline fun <T> Array<out T>.takeWhile(predicate: (T) -> Boolean): List<T>
inline fun BooleanArray.takeWhile(predicate: (Boolean) -> Boolean): List<Boolean>
inline fun ByteArray.takeWhile(predicate: (Byte) -> Boolean): List<Byte>
inline fun CharArray.takeWhile(predicate: (Char) -> Boolean): List<Char>
inline fun DoubleArray.takeWhile(predicate: (Double) -> Boolean): List<Double>
inline fun FloatArray.takeWhile(predicate: (Float) -> Boolean): List<Float>
inline fun IntArray.takeWhile(predicate: (Int) -> Boolean): List<Int>
inline fun LongArray.takeWhile(predicate: (Long) -> Boolean): List<Long>
inline fun ShortArray.takeWhile(predicate: (Short) -> Boolean): List<Short>
inline fun UByteArray.takeWhile(predicate: (UByte) -> Boolean): List<UByte>
inline fun UIntArray.takeWhile(predicate: (UInt) -> Boolean): List<UInt>
inline fun ULongArray.takeWhile(predicate: (ULong) -> Boolean): List<ULong>
inline fun UShortArray.takeWhile(predicate: (UShort) -> Boolean): List<UShort>
inline fun <T> Iterable<T>.takeWhile(predicate: (T) -> Boolean): List<T>
Link copied to clipboard
fun BooleanArray.toBooleanArray(): BooleanArray
fun Collection<Boolean>.toBooleanArray(): BooleanArray
Link copied to clipboard
fun ByteArray.toByteArray(): ByteArray
inline fun UByteArray.toByteArray(): ByteArray
fun Collection<Byte>.toByteArray(): ByteArray
Link copied to clipboard
fun CharArray.toCharArray(): CharArray
fun Collection<Char>.toCharArray(): CharArray
Link copied to clipboard
fun <T, C : MutableCollection<in T>> Array<out T>.toCollection(destination: C): C
fun <C : MutableCollection<in Boolean>> BooleanArray.toCollection(destination: C): C
fun <C : MutableCollection<in Byte>> ByteArray.toCollection(destination: C): C
fun <C : MutableCollection<in Char>> CharArray.toCollection(destination: C): C
fun <C : MutableCollection<in Double>> DoubleArray.toCollection(destination: C): C
fun <C : MutableCollection<in Float>> FloatArray.toCollection(destination: C): C
fun <C : MutableCollection<in Int>> IntArray.toCollection(destination: C): C
fun <C : MutableCollection<in Long>> LongArray.toCollection(destination: C): C
fun <C : MutableCollection<in Short>> ShortArray.toCollection(destination: C): C
fun <T, C : MutableCollection<in T>> Iterable<T>.toCollection(destination: C): C
Link copied to clipboard
fun DoubleArray.toDoubleArray(): DoubleArray
fun Collection<Double>.toDoubleArray(): DoubleArray
Link copied to clipboard
fun FloatArray.toFloatArray(): FloatArray
fun Collection<Float>.toFloatArray(): FloatArray
Link copied to clipboard
fun <T> Array<out T>.toHashSet(): HashSet<T>
fun BooleanArray.toHashSet(): HashSet<Boolean>
fun ByteArray.toHashSet(): HashSet<Byte>
fun CharArray.toHashSet(): HashSet<Char>
fun DoubleArray.toHashSet(): HashSet<Double>
fun FloatArray.toHashSet(): HashSet<Float>
fun IntArray.toHashSet(): HashSet<Int>
fun LongArray.toHashSet(): HashSet<Long>
fun ShortArray.toHashSet(): HashSet<Short>
fun <T> Iterable<T>.toHashSet(): HashSet<T>
Link copied to clipboard
fun IntArray.toIntArray(): IntArray
inline fun UIntArray.toIntArray(): IntArray
fun Collection<Int>.toIntArray(): IntArray
Link copied to clipboard
fun <T> Array<out T>.toList(): List<T>
fun BooleanArray.toList(): List<Boolean>
fun ByteArray.toList(): List<Byte>
fun CharArray.toList(): List<Char>
fun DoubleArray.toList(): List<Double>
fun FloatArray.toList(): List<Float>
fun IntArray.toList(): List<Int>
fun LongArray.toList(): List<Long>
fun ShortArray.toList(): List<Short>
fun <T> Iterable<T>.toList(): List<T>
fun <K, V> Map<out K, V>.toList(): List<Pair<K, V>>
Link copied to clipboard
fun LongArray.toLongArray(): LongArray
inline fun ULongArray.toLongArray(): LongArray
fun Collection<Long>.toLongArray(): LongArray
Link copied to clipboard
fun <K, V> Array<out Pair<K, V>>.toMap(): Map<K, V>
fun <K, V> Iterable<Pair<K, V>>.toMap(): Map<K, V>
fun <K, V> Map<out K, V>.toMap(): Map<K, V>
fun <K, V> Sequence<Pair<K, V>>.toMap(): Map<K, V>
fun <K, V, M : MutableMap<in K, in V>> Array<out Pair<K, V>>.toMap(destination: M): M
fun <K, V, M : MutableMap<in K, in V>> Iterable<Pair<K, V>>.toMap(destination: M): M
fun <K, V, M : MutableMap<in K, in V>> Map<out K, V>.toMap(destination: M): M
fun <K, V, M : MutableMap<in K, in V>> Sequence<Pair<K, V>>.toMap(destination: M): M
Link copied to clipboard
fun <T> Array<out T>.toMutableList(): MutableList<T>
fun BooleanArray.toMutableList(): MutableList<Boolean>
fun ByteArray.toMutableList(): MutableList<Byte>
fun CharArray.toMutableList(): MutableList<Char>
fun DoubleArray.toMutableList(): MutableList<Double>
fun FloatArray.toMutableList(): MutableList<Float>
fun IntArray.toMutableList(): MutableList<Int>
fun LongArray.toMutableList(): MutableList<Long>
fun ShortArray.toMutableList(): MutableList<Short>
fun <T> Collection<T>.toMutableList(): MutableList<T>
fun <T> Iterable<T>.toMutableList(): MutableList<T>
Link copied to clipboard
fun <K, V> Map<out K, V>.toMutableMap(): MutableMap<K, V>
Link copied to clipboard
fun <T> Array<out T>.toMutableSet(): MutableSet<T>
fun BooleanArray.toMutableSet(): MutableSet<Boolean>
fun ByteArray.toMutableSet(): MutableSet<Byte>
fun CharArray.toMutableSet(): MutableSet<Char>
fun DoubleArray.toMutableSet(): MutableSet<Double>
fun FloatArray.toMutableSet(): MutableSet<Float>
fun IntArray.toMutableSet(): MutableSet<Int>
fun LongArray.toMutableSet(): MutableSet<Long>
fun ShortArray.toMutableSet(): MutableSet<Short>
fun <T> Iterable<T>.toMutableSet(): MutableSet<T>
Link copied to clipboard
inline fun <K, V> Map.Entry<K, V>.toPair(): Pair<K, V>
Link copied to clipboard
fun <T> Array<out T>.toSet(): Set<T>
fun BooleanArray.toSet(): Set<Boolean>
fun ByteArray.toSet(): Set<Byte>
fun CharArray.toSet(): Set<Char>
fun DoubleArray.toSet(): Set<Double>
fun FloatArray.toSet(): Set<Float>
fun IntArray.toSet(): Set<Int>
fun LongArray.toSet(): Set<Long>
fun ShortArray.toSet(): Set<Short>
fun <T> Iterable<T>.toSet(): Set<T>
Link copied to clipboard
fun ShortArray.toShortArray(): ShortArray
inline fun UShortArray.toShortArray(): ShortArray
fun Collection<Short>.toShortArray(): ShortArray
Link copied to clipboard
fun BooleanArray.toTypedArray(): BooleanArray
fun ByteArray.toTypedArray(): ByteArray
fun CharArray.toTypedArray(): CharArray
fun DoubleArray.toTypedArray(): DoubleArray
fun FloatArray.toTypedArray(): FloatArray
fun IntArray.toTypedArray(): IntArray
fun LongArray.toTypedArray(): LongArray
fun ShortArray.toTypedArray(): ShortArray
fun UByteArray.toTypedArray(): Array<UByte>
fun UIntArray.toTypedArray(): Array<UInt>
fun ULongArray.toTypedArray(): Array<ULong>
inline fun <T> Collection<T>.toTypedArray(): Array<T>
Link copied to clipboard
fun Array<out UByte>.toUByteArray(): UByteArray
inline fun ByteArray.toUByteArray(): UByteArray
Link copied to clipboard
fun Array<out UInt>.toUIntArray(): UIntArray
inline fun IntArray.toUIntArray(): UIntArray
Link copied to clipboard
fun Array<out ULong>.toULongArray(): ULongArray
inline fun LongArray.toULongArray(): ULongArray
Link copied to clipboard
fun Array<out UShort>.toUShortArray(): UShortArray
inline fun ShortArray.toUShortArray(): UShortArray
Link copied to clipboard
infix fun <T> Array<out T>.union(other: Iterable<T>): Set<T>
infix fun BooleanArray.union(other: Iterable<Boolean>): Set<Boolean>
infix fun ByteArray.union(other: Iterable<Byte>): Set<Byte>
infix fun CharArray.union(other: Iterable<Char>): Set<Char>
infix fun DoubleArray.union(other: Iterable<Double>): Set<Double>
infix fun FloatArray.union(other: Iterable<Float>): Set<Float>
infix fun IntArray.union(other: Iterable<Int>): Set<Int>
infix fun LongArray.union(other: Iterable<Long>): Set<Long>
infix fun ShortArray.union(other: Iterable<Short>): Set<Short>
infix fun <T> Iterable<T>.union(other: Iterable<T>): Set<T>
Link copied to clipboard
fun <T, R> Array<out Pair<T, R>>.unzip(): Pair<List<T>, List<R>>
fun <T, R> Iterable<Pair<T, R>>.unzip(): Pair<List<T>, List<R>>
Link copied to clipboard
fun <T> Iterable<T>.windowed(size: Int, step: Int)
fun <T, R> Iterable<T>.windowed(size: Int, step: Int)
Link copied to clipboard
fun <K, V> Map<K, V>.withDefault(defaultValue: (key: K) -> V): Map<K, V>
@JvmName(name = "withDefaultMutable")
fun <K, V> MutableMap<K, V>.withDefault(defaultValue: (key: K) -> V): MutableMap<K, V>
Link copied to clipboard
fun <T> Array<out T>.withIndex(): Iterable<IndexedValue<T>>
fun BooleanArray.withIndex(): Iterable<IndexedValue<Boolean>>
fun ByteArray.withIndex(): Iterable<IndexedValue<Byte>>
fun CharArray.withIndex(): Iterable<IndexedValue<Char>>
fun DoubleArray.withIndex(): Iterable<IndexedValue<Double>>
fun FloatArray.withIndex(): Iterable<IndexedValue<Float>>
fun IntArray.withIndex(): Iterable<IndexedValue<Int>>
fun LongArray.withIndex(): Iterable<IndexedValue<Long>>
fun ShortArray.withIndex(): Iterable<IndexedValue<Short>>
fun <T> Iterable<T>.withIndex(): Iterable<IndexedValue<T>>
fun <T> Iterator<T>.withIndex(): Iterator<IndexedValue<T>>
Link copied to clipboard
infix fun <T, R> Array<out T>.zip(other: Array<out R>): List<Pair<T, R>>
infix fun <T, R> Array<out T>.zip(other: Iterable<R>): List<Pair<T, R>>
infix fun <R> BooleanArray.zip(other: Array<out R>): List<Pair<Boolean, R>>
infix fun BooleanArray.zip(other: BooleanArray): List<Pair<Boolean, Boolean>>
infix fun <R> BooleanArray.zip(other: Iterable<R>): List<Pair<Boolean, R>>
infix fun <R> ByteArray.zip(other: Array<out R>): List<Pair<Byte, R>>
infix fun ByteArray.zip(other: ByteArray): List<Pair<Byte, Byte>>
infix fun <R> ByteArray.zip(other: Iterable<R>): List<Pair<Byte, R>>
infix fun <R> CharArray.zip(other: Array<out R>): List<Pair<Char, R>>
infix fun CharArray.zip(other: CharArray): List<Pair<Char, Char>>
infix fun <R> CharArray.zip(other: Iterable<R>): List<Pair<Char, R>>
infix fun <R> DoubleArray.zip(other: Array<out R>): List<Pair<Double, R>>
infix fun DoubleArray.zip(other: DoubleArray): List<Pair<Double, Double>>
infix fun <R> DoubleArray.zip(other: Iterable<R>): List<Pair<Double, R>>
infix fun <R> FloatArray.zip(other: Array<out R>): List<Pair<Float, R>>
infix fun FloatArray.zip(other: FloatArray): List<Pair<Float, Float>>
infix fun <R> FloatArray.zip(other: Iterable<R>): List<Pair<Float, R>>
infix fun <R> IntArray.zip(other: Array<out R>): List<Pair<Int, R>>
infix fun IntArray.zip(other: IntArray): List<Pair<Int, Int>>
infix fun <R> IntArray.zip(other: Iterable<R>): List<Pair<Int, R>>
infix fun <R> LongArray.zip(other: Array<out R>): List<Pair<Long, R>>
infix fun LongArray.zip(other: LongArray): List<Pair<Long, Long>>
infix fun <R> LongArray.zip(other: Iterable<R>): List<Pair<Long, R>>
infix fun <R> ShortArray.zip(other: Array<out R>): List<Pair<Short, R>>
infix fun ShortArray.zip(other: ShortArray): List<Pair<Short, Short>>
infix fun <R> ShortArray.zip(other: Iterable<R>): List<Pair<Short, R>>
infix fun <R> UByteArray.zip(other: Array<out R>): List<Pair<UByte, R>>
infix fun UByteArray.zip(other: UByteArray): List<Pair<UByte, UByte>>
infix fun <R> UByteArray.zip(other: Iterable<R>): List<Pair<UByte, R>>
infix fun <R> UIntArray.zip(other: Array<out R>): List<Pair<UInt, R>>
infix fun UIntArray.zip(other: UIntArray): List<Pair<UInt, UInt>>
infix fun <R> UIntArray.zip(other: Iterable<R>): List<Pair<UInt, R>>
infix fun <R> ULongArray.zip(other: Array<out R>): List<Pair<ULong, R>>
infix fun ULongArray.zip(other: ULongArray): List<Pair<ULong, ULong>>
infix fun <R> ULongArray.zip(other: Iterable<R>): List<Pair<ULong, R>>
infix fun <R> UShortArray.zip(other: Array<out R>): List<Pair<UShort, R>>
infix fun UShortArray.zip(other: UShortArray): List<Pair<UShort, UShort>>
infix fun <R> UShortArray.zip(other: Iterable<R>): List<Pair<UShort, R>>
infix fun <T, R> Iterable<T>.zip(other: Array<out R>): List<Pair<T, R>>
infix fun <T, R> Iterable<T>.zip(other: Iterable<R>): List<Pair<T, R>>
inline fun <T, R, V> Array<out T>.zip(other: Array<out R>, transform: (a: T, b: R) -> V): List<V>
inline fun <T, R, V> Array<out T>.zip(other: Iterable<R>, transform: (a: T, b: R) -> V): List<V>
inline fun <R, V> BooleanArray.zip(other: Array<out R>, transform: (a: Boolean, b: R) -> V): List<V>
inline fun <V> BooleanArray.zip(other: BooleanArray, transform: (a: Boolean, b: Boolean) -> V): List<V>
inline fun <R, V> BooleanArray.zip(other: Iterable<R>, transform: (a: Boolean, b: R) -> V): List<V>
inline fun <R, V> ByteArray.zip(other: Array<out R>, transform: (a: Byte, b: R) -> V): List<V>
inline fun <V> ByteArray.zip(other: ByteArray, transform: (a: Byte, b: Byte) -> V): List<V>
inline fun <R, V> ByteArray.zip(other: Iterable<R>, transform: (a: Byte, b: R) -> V): List<V>
inline fun <R, V> CharArray.zip(other: Array<out R>, transform: (a: Char, b: R) -> V): List<V>
inline fun <V> CharArray.zip(other: CharArray, transform: (a: Char, b: Char) -> V): List<V>
inline fun <R, V> CharArray.zip(other: Iterable<R>, transform: (a: Char, b: R) -> V): List<V>
inline fun <R, V> DoubleArray.zip(other: Array<out R>, transform: (a: Double, b: R) -> V): List<V>
inline fun <V> DoubleArray.zip(other: DoubleArray, transform: (a: Double, b: Double) -> V): List<V>
inline fun <R, V> DoubleArray.zip(other: Iterable<R>, transform: (a: Double, b: R) -> V): List<V>
inline fun <R, V> FloatArray.zip(other: Array<out R>, transform: (a: Float, b: R) -> V): List<V>
inline fun <V> FloatArray.zip(other: FloatArray, transform: (a: Float, b: Float) -> V): List<V>
inline fun <R, V> FloatArray.zip(other: Iterable<R>, transform: (a: Float, b: R) -> V): List<V>
inline fun <R, V> IntArray.zip(other: Array<out R>, transform: (a: Int, b: R) -> V): List<V>
inline fun <V> IntArray.zip(other: IntArray, transform: (a: Int, b: Int) -> V): List<V>
inline fun <R, V> IntArray.zip(other: Iterable<R>, transform: (a: Int, b: R) -> V): List<V>
inline fun <R, V> LongArray.zip(other: Array<out R>, transform: (a: Long, b: R) -> V): List<V>
inline fun <V> LongArray.zip(other: LongArray, transform: (a: Long, b: Long) -> V): List<V>
inline fun <R, V> LongArray.zip(other: Iterable<R>, transform: (a: Long, b: R) -> V): List<V>
inline fun <R, V> ShortArray.zip(other: Array<out R>, transform: (a: Short, b: R) -> V): List<V>
inline fun <V> ShortArray.zip(other: ShortArray, transform: (a: Short, b: Short) -> V): List<V>
inline fun <R, V> ShortArray.zip(other: Iterable<R>, transform: (a: Short, b: R) -> V): List<V>
inline fun <R, V> UByteArray.zip(other: Array<out R>, transform: (a: UByte, b: R) -> V): List<V>
inline fun <V> UByteArray.zip(other: UByteArray, transform: (a: UByte, b: UByte) -> V): List<V>
inline fun <R, V> UByteArray.zip(other: Iterable<R>, transform: (a: UByte, b: R) -> V): List<V>
inline fun <R, V> UIntArray.zip(other: Array<out R>, transform: (a: UInt, b: R) -> V): List<V>
inline fun <V> UIntArray.zip(other: UIntArray, transform: (a: UInt, b: UInt) -> V): List<V>
inline fun <R, V> UIntArray.zip(other: Iterable<R>, transform: (a: UInt, b: R) -> V): List<V>
inline fun <R, V> ULongArray.zip(other: Array<out R>, transform: (a: ULong, b: R) -> V): List<V>
inline fun <V> ULongArray.zip(other: ULongArray, transform: (a: ULong, b: ULong) -> V): List<V>
inline fun <R, V> ULongArray.zip(other: Iterable<R>, transform: (a: ULong, b: R) -> V): List<V>
inline fun <R, V> UShortArray.zip(other: Array<out R>, transform: (a: UShort, b: R) -> V): List<V>
inline fun <V> UShortArray.zip(other: UShortArray, transform: (a: UShort, b: UShort) -> V): List<V>
inline fun <R, V> UShortArray.zip(other: Iterable<R>, transform: (a: UShort, b: R) -> V): List<V>
inline fun <T, R, V> Iterable<T>.zip(other: Array<out R>, transform: (a: T, b: R) -> V): List<V>
inline fun <T, R, V> Iterable<T>.zip(other: Iterable<R>, transform: (a: T, b: R) -> V): List<V>
Link copied to clipboard
fun <T> Iterable<T>.zipWithNext(): List<Pair<T, T>>
inline fun <T, R> Iterable<T>.zipWithNext(transform: (a: T, b: T) -> R): List<R>

Properties

Link copied to clipboard
val <T> Array<out T>.indices: IntRange
val BooleanArray.indices: IntRange
val ByteArray.indices: IntRange
val CharArray.indices: IntRange
val DoubleArray.indices: IntRange
val FloatArray.indices: IntRange
val IntArray.indices: IntRange
val LongArray.indices: IntRange
val ShortArray.indices: IntRange
val UByteArray.indices: IntRange
val UIntArray.indices: IntRange
val ULongArray.indices: IntRange
val UShortArray.indices: IntRange
val Collection<*>.indices: IntRange
Link copied to clipboard
val <T> Array<out T>.lastIndex: Int
val BooleanArray.lastIndex: Int
val ByteArray.lastIndex: Int
val CharArray.lastIndex: Int
val DoubleArray.lastIndex: Int
val FloatArray.lastIndex: Int
val IntArray.lastIndex: Int
val LongArray.lastIndex: Int
val ShortArray.lastIndex: Int
val UByteArray.lastIndex: Int
val UIntArray.lastIndex: Int
val ULongArray.lastIndex: Int
val UShortArray.lastIndex: Int
val <T> List<T>.lastIndex: Int